Dev on Build in Public

Supabase is my new favorite database

Tue, 07 Apr 2026 00:00:00 +0000

Since the early days of poketto.me, I’ve been dissatisfied with my persistence architecture. I started with Google Cloud SQL, but I quickly realized that it was too expensive for a small app. I switched to Firebase and had Claude do the replatforming, if you remember. However, when I introduced full-text search, I had to add BigQuery as a second database just for that because Firebase doesn’t have full-text indexing. The point is: It’s a lot of headaches for something that should be easy.

Stopping the scrape: Why I switched to the Wikimedia API

Sat, 04 Oct 2025 00:00:00 +0000

I’ve noticed a welcome uptick in users saving Wikipedia articles to poketto.me recently.

But until now, the app treated Wikipedia just like any other website: it scraped the raw HTML. Turns out, for Wikipedia, that is far from ideal:

🤯 Artifacts: The extracted content often included UI clutter like “Edit” buttons, navigation links, and “Citation missing” tags.

📋 Rendering issues: The standard HTML → Markdown → HTML conversion pipeline introduced plenty of ugly formatting glitches specific to wikis.

Be careful when counting your whitespace

Fri, 03 Oct 2025 00:00:00 +0000

One of the great things about working on poketto.me is that I'm constantly learning about fascinating linguistic subtleties. For instance, while working on automatic content summaries and extracting key facts and figures, I came across an interesting issue with token counting in Chinese script.

I had put a safeguard in place so that poketto.me would only attempt to summarize content longer than 100 words. This works well for German and English content, but when I tested the feature on an article published by Xinhua, a Chinese news agency, my code said the article had only about 12 words, which was obviously incorrect, so it didn't produce a summary.

BigQuery’s SEARCH function only works with ASCII characters

Thu, 02 Oct 2025 00:00:00 +0000

Admittedly, it may not have been my brightest idea to use BigQuery as the search backend for poketto.me. But since Firebase doesn’t have built-in full-text search, I would have needed to add another tool to my stack anyway. I figured BigQuery would be easier than managing something external like Apache Lucene or Elasticsearch. Plus, BigQuery has a built-in SEARCH(...) function, so why not give it a try?

As it turns out, SEARCH(...) is really more of a token-based text analyzer than a true search function:
1️⃣ It splits both the search term and the text into tokens (words).
2️⃣ It matches full tokens only.
3️⃣ It returns just TRUE or FALSE—no offsets, no match lengths.
🤯 And worst of all: It only works with ASCII. Yes. Like it’s 1979.

Angular data binding with arrays: Yes, it can work!

Tue, 30 Sep 2025 00:00:00 +0000

Angular is awesome. And data binding, in particular, has been a game changer for developing modern web apps. Something changes somewhere and—magically—every part of your UI that needs to respond does so.

However, I’ve always struggled with one corner case: What if you’re binding to an array, and the change that occurs is that something gets added or removed, and you need to respond to the change programmatically (not just in your HTML template)?

How to fix the ominous Android Status Bar Issue

Mon, 29 Sep 2025 00:00:00 +0000

Remember Capacitor + Android Status Bar = 🤯?

🪲 This bug has haunted me for months—stalling the Android release of poketto.me and draining way too much mental energy. It’s one of those dreaded dev problems: no obvious solution, hard to debug, and endless rabbit holes.

Eventually, I had to bite the bullet and dig in. Here’s what I found:

💣 Issue #1: The Capacitor status bar plugin only half-works. There’s a StatusBar.setOverlaysWebView(true/false) API, but on modern Android versions it doesn’t behave as advertised. Why?

The memory consumption patterns of LangChain are… disturbing

Fri, 26 Sep 2025 00:00:00 +0000

As I said in No, you don’t have to learn LangChain, we shouldn’t get distracted by the artificial complexity introduced by our frameworks. LangChain is mostly a wrapper around the REST APIs of various LLM providers. Useful? Yes—switching between models becomes easy.

But here’s a mystery I can’t explain.

When I added Gemini as a fallback to DeepSeek (see yesterday’s post about DeepSeek refusing to touch Chinese politics), I thought it would be straightforward:

DeepSeek really won’t touch anything related to Chinese politics

Thu, 25 Sep 2025 00:00:00 +0000

For most use cases in poketto.me, I’m pretty happy with #DeepSeek: it’s cheap, reliable, and the output quality matches any other LLM I’ve tried.

But there’s one big caveat: anything related to Chinese politics can trigger an immediate refusal. Example: Right after the launch of poketto.me, a user tried saving an article about the September 3rd Beijing meeting between Xi Jinping, Vladimir Putin, Kim Jong Un, et al. ( https://orf.at/stories/3404330/)

You can customize the text selection menu in your Android app

Mon, 22 Sep 2025 00:00:00 +0000

As I mentioned in In-place DOM manipulation: Thorny as ever, text selection in browsers can get tricky fast. For poketto.me, the challenge was even bigger: the web app runs inside a hosted WebView in an Android app.

Mobile text selection already behaves differently from desktop, and the embedding scenario didn’t make things easier. After wrestling with a few awkward bugs, though, I found an elegant solution.

On the web, when a user finishes selecting text, poketto.me immediately converts the selection into a highlight (default color). On Android, however, a tiny system context menu pops up with entries like Copy, Select All, Web Search, etc. At first this got in the way—but it turns out you can customize this menu on a per-activity basis!

The Gemini API for Video Understanding is surprisingly good

Sun, 21 Sep 2025 00:00:00 +0000

As I mentioned in Gemini’s URL Context feature is 90% hype, 10% value, I was pretty disappointed with Gemini’s “URL Context” feature. But “Video Understanding”? That one actually works like a charm.

How it works:

👉 Provide a YouTube video link
👉 Ask Gemini questions about the video
👉 Get a structured response back

For poketto.me, this unlocks a really neat feature: users can save any YouTube video in the app and either watch it later or read a textual description of the video.

Gemini’s “URL Context” feature is 90% hype, 10% value

Sat, 20 Sep 2025 00:00:00 +0000

I’ll admit—I was pretty excited when Google announced that the Gemini API would support a new “URL Context” tool. The idea: you could “ask” Gemini about the content of a specific web page, with Google handling all the heavy lifting.

The documentation even shows a neat example: send Gemini two recipe URLs and prompt it to compare ingredients and cooking times. If it worked, this would’ve been a game-changer for poketto.me:

There is no cloud (it’s just somebody else’s computer)

Thu, 18 Sep 2025 00:00:00 +0000

…and ultimately, that “someone” is going to send you a real invoice for actual money. In my case, I’m running poketto.me almost entirely on Google Cloud. While it’s not terribly expensive right now, it is a cost I had to factor into my pricing strategy.

But here’s the good news: Google offers various programs to support early-stage startups! Check out https://cloud.google.com/startup?hl=en for details.

Today, I’m happy to share that poketto.me made it into the “START” tier of that program, which means: no Google Cloud bills in my mailbox for the foreseeable future!

In-place DOM manipulation: Thorny as ever 🥀

Mon, 15 Sep 2025 00:00:00 +0000

The “highlights” feature in the poketto.me reader looks deceptively simple: select a text range, and it gets highlighted in yellow. Clicking a highlight opens a small context menu to change its color or delete it.

But the implementation? Much thornier than you’d think. Why?

1️⃣ Browser selections are relative to visible text, not the underlying DOM tree of the rendered HTML.
2️⃣ A selection is defined by the text plus its start offset (characters before the selection) and end offset.
3️⃣ To do anything useful with a selection (beyond copying text to the clipboard), you have to map it back to its position in the DOM tree.
4️⃣ That “mapping” is, to some extent, impossible to get perfectly right. A selection can span multiple nodes, start and end at different levels of depth, and include irrelevant nodes.

Posthog also works well for feature flagging

Sun, 14 Sep 2025 00:00:00 +0000

Since adopting Posthog for user analytics at poketto.me, I’ve grown pretty fond of the tool. Beyond the basics and advanced insights, I’m now also using it for feature flagging.

Fine-grained control (and easy rollback) of new features or major changes is becoming increasingly important as the poketto.me user base grows. Why?

🤕 In a B2C app, you can’t count on users to complain when something breaks—they’ll just leave. Especially for early-stage products, every irritated user is a missed opportunity.

Firefox extensions (mostly) work on Firefox on Android as well

Fri, 12 Sep 2025 00:00:00 +0000

A poketto.me Firefox user recently pointed out that Firefox on Android also supports browser extensions– but that the poketto.me extension didn’t appear on Mozilla’s Add-Ons page there.

Turns out: Any modern browser extension built on the standard APIs (Chrome, Firefox, Edge) can also run in Firefox on Android. But when publishing, you have to explicitly test and target Android.

Technically, the extension “just works”—as long as you’re not doing anything exotic with the APIs. But aesthetically, there’s one big caveat.

trafilatura’s image extraction is a bit too cautious for my taste

Thu, 11 Sep 2025 00:00:00 +0000

A poketto.me user recently filed a curious bug: They had saved a page that clearly contained images — but in the reader view, no images showed up.

I expected some quirky HTML. But when I checked, the <img> tags looked perfectly normal (see Exhibit A). Yet, after passing the HTML through trafilatura (which I use to convert HTML to Markdown), the images had simply vanished.

🔎 The culprit? Trafilatura is very cautious with images. It only accepts <img src=...> URLs that end with a known extension (.jpg, .png, .gif, …). The site in question served images from URLs without extensions — so trafilatura just ignored them.

Product analytics is more than DAU and WAU

Wed, 10 Sep 2025 00:00:00 +0000

Recently, I wrote about adopting Posthog for poketto.me. At first, I thought I’d use it for the basics:

📆 Daily & weekly active users (DAU/WAU)
📎 Core events (URLs saved, links shared, etc.)
🚨 Error tracking and alerting

But then I realized: analytics can do much more. In fact, Posthog replaced one of my home-grown tools — my “podcast heuristic accuracy guestimator.” Let me explain.

When a user adds content to their podcast feed, poketto.me has to gauge three things:

Entitlements are easy (until they’re not)

Tue, 09 Sep 2025 00:00:00 +0000

Early-stage products are all about uncertainty. With poketto.me, I started by building something I wanted to use — and gave it away for free. Then came early adopters asking for features, and eventually I began experimenting with monetizable “premium” features: personalized podcasts, news aggregation, summaries, contextualization, etc.

That third bucket quickly gave me headaches. I needed a way to put usage guardrails around these features:

👉 to separate free from premium,
👉 to distinguish “beta” from production-ready,
👉 and to keep my future monetization options open.

A room without a dustbin will never be clean

Mon, 08 Sep 2025 00:00:00 +0000

This is a roundabout way of saying: make “good” behavior the easy choice. But there’s an interesting backstory to the saying.

I come from a family of manual laborers. My dad, all of my uncles, and most of my many cousins work in trades ranging from carpentry to plumbing to house painting. And one of the first things any good craftsman does when setting up at a new site? Installing a dustbin.

Debugging your Stripe integration is easy with Stripe CLI

Sun, 07 Sep 2025 00:00:00 +0000

I put off building checkout and payments for the premium version of poketto.me for way too long. The thought of integrating with Stripe — keeping “their” and “my” data in sync, handling callbacks, connecting the UI, smoothing out user flows… it always felt like too much to tackle on any given day.

But once I committed to a GA date for the premium version, I had to bite the bullet.

Product analytics? PostHog is my tool of choice!

Sat, 06 Sep 2025 00:00:00 +0000

Event tracking and analytics is one of those cross-cutting topics I mentioned back in You don’t need to bring out the big guns right away (but it’s good to know them anyway): in the beginning, it doesn’t really matter if or how you do it. Often, you can just hack something together and move on to more important things. For the longest time, for example, poketto.me just had a hard-coded email notification that let me know whenever a new user signed up. That was enough to give me a general sense of what was going on.

Your browser extension doesn’t necessarily need that many permissions

Thu, 04 Sep 2025 00:00:00 +0000

The other week, I was building a neat little feature for the poketto.me browser extensions (Chrome, Firefox, and Edge): when you save a web page, the extension should capture not just the URL, but the entire content you’re looking at in that moment.

🤨Why does this matter?

If you’re signed in on a page (say, with your New York Times subscription), poketto.me can capture the full article — just as you, the paying subscriber, see it. Otherwise, poketto.me tries to fetch the article in the background… but it will run straight into the paywall (see TIL #59).

Always suspect your own code first

Tue, 02 Sep 2025 00:00:00 +0000

I physically winced when a beta tester of the poketto.me Android app reported this bug:

“Sometimes, adding new tags to a Save doesn’t work. I open the tagging dialog, type a new tag, click ‘save’ — the input field clears, but the new tag is nowhere to be seen.”

I was able to reproduce the issue on my phone and in an Android emulator.
Gut reaction: “Ah, must be the WebView. WebViews always behave differently than a normal browser. This will be a mess.”

Social media “previews” are tricky (part 2)

Mon, 01 Sep 2025 00:00:00 +0000

Yesterday, I described my elegant solution to the social media “preview” problem: Direct the share URL to the Python backend, render a skeleton HTML page with machine-readable metadata, and send real browsers to the Angular app’s proper “read” page.

But… how exactly do you redirect the user?

My first, naive idea was to use the age-old HTML redirect tag:

<meta http-equiv="refresh" content="0; url=http://example.com/" \>

My assumption: social media bots wouldn’t follow these “semantic” redirects, but they would follow HTTP redirects (which they definitely do). This worked perfectly — except for LinkedIn 😅

Social media “previews” are tricky (part 1)

Sun, 31 Aug 2025 00:00:00 +0000

When you add a link to a website to post on Bluesky, Facebook, or LinkedIn, your post will often contain a “preview” of the target page. That’s great — it makes the post more appealing and more likely to get clicks. But how do social media platforms fetch the exact content they embed in that preview? That’s… a tiny rabbit hole.

Enter: the “Share…” feature of poketto.me. You can share any saved content with others via poketto.me. Anyone who opens the link gets the same distraction-free reading experience, whether or not they use poketto.me.

Firefox and Chrome (finally!) support the same extension API (and so does Microsoft Edge)

Sat, 30 Aug 2025 00:00:00 +0000

I hadn’t actually planned to build a Firefox extension for poketto.me. But among the first wave of “Pocket Converts” — users who turned to poketto.me after reading about it as an alternative to Pocket — several asked for a Firefox extension. So, I decided to do a quick technical feasibility check.

As it turns out: The Chrome extension works in Firefox without a single code change!

Apparently, there are a few APIs that Firefox doesn’t support (see: https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/Browser_support_for_JavaScript_APIs), but luckily, I didn’t rely on any of those.

Don’t generalize too soon. But do generalize.

Fri, 29 Aug 2025 00:00:00 +0000

It’s generally good practice among developers to break things down into small, independent, reusable components. But, like all good things, it can become problematic when taken too far too soon.

Here’s an example from poketto.me:

A few weeks ago, I introduced colored tags. Users can choose one of eight colors for each tag to help them quickly find what they’re looking for and organize their tags visually. (Personally, I use one color for all location-related tags, another for tech topics, etc.)

The occasional toast can’t hurt

Wed, 27 Aug 2025 00:00:00 +0000

Some of the designers and frontend devs I’ve worked with may remember my rants against toast notifications:

“Why do I need a success message for every action? I expect things to work. Only tell me when something breaks.”

But… I’ll admit it: Sometimes toasts do have their merit.

Two examples from poketto.me:

🔹 Copy to clipboard (Podcast feed URL):

When users click the “copy” button, the action happens instantly. But without any feedback, it feels… awkward.

Multi-threaded TTS: A bad idea

Tue, 26 Aug 2025 00:00:00 +0000

Running text-to-speech in the cloud is fun—until it isn’t.

Early on, I didn’t think much about thread safety. During my own testing, rarely would more than one TTS task be running in parallel, so there were no big issues. But once more users started using the feature, strange bugs popped up:

Errors like “Assertion srcIndex < srcSelectDimSize failed” started showing up in the logs—and worse, once triggered, the entire Cloud Run instance would become unusable until a redeploy.

Object.assign(...) in JavaScript helps with asynchronous updates

Thu, 21 Aug 2025 00:00:00 +0000

In WebSockets: More than tech vanity, I talked about the implicit user value of asynchronous UIs. Today, here’s a neat little JavaScript trick I hadn’t been aware of that makes implementing them a bit easier: Object.assign(...).

Here’s the situation:

Your Angular frontend initially fetches a list of items from the backend. Thanks to Angular’s powerful data binding, many components reference properties of these objects. Later, the backend sends an updated version of one of these items via WebSocket. What now?

WebSockets: More than tech vanity

Wed, 20 Aug 2025 00:00:00 +0000

As I said in Socket science isn’t rocket science, WebSockets are quite easy to use with Python + Flask + Socket.IO on the backend and Angular + Socket.IO + RxJS on the frontend. But why bother? Dealing with asynchronous requests is more of a hassle than not. And for a “boring” app like poketto.me, aren’t synchronous HTTP requests/responses good enough?

Here are two use cases where, despite the app’s apparent simplicity, asynchronous backend/frontend communication adds real value:

Prompt engineering: A task best left to the machines

Tue, 19 Aug 2025 00:00:00 +0000

Under the hood, poketto.me makes heavy use of LLMs. The podcast feature is a great example: Users can turn any web content into a podcast, but often that content isn’t well-suited for listening. LLMs are great at optimizing this—simplifying complex sentences, turning headlines into enumerations, describing images verbally, etc.

But the challenge: How do you craft a single, generic prompt that works across all types of content and runs unsupervised via the API?

Extracting Favicons: There’s No Bulletproof Way

Sat, 16 Aug 2025 00:00:00 +0000

A favicon is that tiny icon you see next to a site name in your browser tab or bookmarks bar. It's one of those small UX elements that quietly plays a big role in how we recognize and visually differentiate websites.

In poketto.me, I wanted to bring favicons into play for a couple of UI elements—particularly when managing your saved news sources. Seeing a little logo beside each source makes skimming, scanning, and organizing much more intuitive than reading domain names alone.

GCS Caching Can Be a Pain in the Neck

Fri, 15 Aug 2025 00:00:00 +0000

I love GCS (Google Cloud Storage). It’s a simple, robust, and powerful solution for storing files online and accessing them either programmatically or via HTTP. Storage is dirt cheap—especially if you don’t need global replication or sophisticated backups. And you can even turn a GCS bucket into an HTTPS-secured, internet-facing web server for static websites. https://poketto.me, for example, runs on that architecture.

Another good use case: the #podcast feature in poketto.me. Naturally, the generated MP3 files need to live somewhere, and storing them in a database or serving them through my Python web server would be… silly. So I push the generated files to a GCS bucket, and all is well: HTTPS-secured, fast, and compatible with any podcast client in the world.

The ABCD rule doesn’t cut it anymore

Wed, 13 Aug 2025 00:00:00 +0000

There was a time when the golden rule of consumer app development was as simple as ABCD: Always Be Collecting Data.

The strategy?
1️⃣ Grow your user base as fast as possible.
2️⃣ Track every interaction, every event, every click.
3️⃣ Figure out how to monetize the data — usually through targeted advertising, if you couldn’t think of anything more creative.

But that game is changing. Consumers are more privacy-aware than ever. Regulators — especially in the EU, California, Japan, and a few other regions — have stepped in. And both founders and investors are realizing that data-harvesting at scale is not a sustainable or ethical business model.

You Don’t Need an nl2br Pipe

Tue, 12 Aug 2025 00:00:00 +0000

This one’s a pretty common hassle: You’ve got text with line breaks (encoded as \n or sometimes \r\n — thanks, Microsoft!), but when rendering that text on a webpage, those line breaks are nowhere to be seen. Naturally, browsers collapse ‘source’ line breaks and ignore them.

The usual reaction? Reach for an nl2br utility — like nl2br-pipe—to manually replace \n with <br /> tags. It’s a well-known workaround in web dev.

Parsing and Serializing XML Is (Still) a Pain in the Neck

Sat, 09 Aug 2025 00:00:00 +0000

It’s 2025, and I still can’t believe I have to say this — but handling XML, especially in Python, remains frustratingly painful.

Take this example: For the upcoming podcast feature of poketto.me, the app will generate a personalized podcast feed for each user, populated with text-to-speech versions of their saved content. Users can subscribe to their custom feed in any podcast app—pretty handy.

The feed itself isn’t complex: just an XML file hosted on a web server (in my case, a GCS bucket) containing metadata and links to episode MP3s. It just needs to comply with Apple’s Podcast RSS Feed Requirements so podcast clients can parse it correctly.
Sounds simple, right?

Consistency Beats Accuracy (Part 2)

Fri, 08 Aug 2025 00:00:00 +0000

The bigger your codebase grows, the more important it becomes to stay consistent — in naming things and in how you use features of your programming language.

Take input parameters and variables, for example. Is the ID of a Save object sometimes named save_id, other times saveId, and occasionally just id? Is the function to load it called load_save(...), get_save(...), or fetch_save(...)? Or maybe it’s load_save(...) for saves, but get_settings(...) and fetch_tag(...) elsewhere?
If so, confusion is only a matter of time.

Google Requires a New versionCode for Every App Bundle You Publish

Wed, 06 Aug 2025 00:00:00 +0000

When publishing a new version of your Android app through the Google Play Console, you must increment the versionCode in your app’s build.gradle file. This is required even if the versionName (the human-readable version string) stays the same.

I found this a bit confusing at first — but the rule is simple: Before you build the bundle you upload to Google Play, make sure you’ve updated the versionCode. If you don’t, your upload will be rejected immediately.

Mind the Gap — flex-gap!

Sat, 02 Aug 2025 00:00:00 +0000

I use flex-based layouts a lot in the #Angular frontend of poketto.me. But I never realized there’s a neat little property called gap (or flex-gap) that lets you define spacing between flex items directly.

For the longest time, I worked around this with clumsy constructs where I’d set margins on child elements — and then unset them on the last child:

.container {
display: flex;
flex-direction: column;
.child {
margin-bottom: 1rem;
&:last-child {
margin-bottom: unset;
}
}
}
```
When really, the world could be so much simpler:
```
.container {
display: flex;
flex-direction: column;
gap: 1rem;
}
```
No more margin hacks.

Firebase as very peculiar limits, or: You don’t want to test in production 🙄

Wed, 30 Jul 2025 00:00:00 +0000

My “user admin” section for poketto.me is quite simple: it lists all registered users, shows when they first (and most recently) used the app, and lets me assign “entitlements” (features like the experimental podcasts and newsfeeds). Works perfectly well on my development instance — but in production, it kept crashing.

Turns out: with Firebase, querying documents where a field value is `in` a list of values isn’t very smart — the list may only contain up to **30 (!) values**.

Capacitor + Android Status Bar = 🤯

Mon, 28 Jul 2025 00:00:00 +0000

The Android status bar (that is, the small bar on top of the screen that shows the current time, the batter status, and notification icons) is really, really weird.

It turns out, Capacitor will, by default, make your app a “fullscreen” app: It’ll render your MainActivity (the one that hosts the WebView which in turn hosts your web app) in such a way that the status bar isn’t there at all–on most devices. On some devices, however, the status bar will be visible, but transparently overlay your app 🤨And, to add insult to injury: It’ll change the font color of the status bar to white, so that if you rapp comes with a white background, all the user sees are some weird optical artifacts at the top of their screen.

You don’t need to bring out the big guns right away (but it’s good to know them anyway)

Sun, 27 Jul 2025 00:00:00 +0000

It’s surprisingly hard to settle on a “fit-for-purpose” technology and tool stack for a modern SaaS / Cloud app.

First of all, there are the technical decisions:

🔀 Which frontend, backend, and persistence stack do you use? Angular vs. React, Java vs. Python, Spring Boot vs. Rails vs. Django vs. Flask, MongoDB vs. Firebase vs. MySQL vs. Postgres…

🔀 Do you run it on AWS (Amazon), GCP (Google Cloud), or Azure (Microsoft)?

GMail’s spam filter is pretty weird

Tue, 22 Jul 2025 00:00:00 +0000

I thought I was being clever when I implemented sign-in via email + one-time token for poketto.me:

✅ No passwords to store

✅ No reliance on external login providers like Google or Facebook

And I had two reliable email services to send those tokens: Hetzner, via their all-inclusive web + mail hosting package I’m using for ralphmayr.com, and Zoho Mail, as a lightweight, email-only solution I’m using for poketto.me.

On paper, everything looked fine: The SMTP server accepted the mail, and the message was sent. Simple, right? Wrong—especially when Gmail is on the receiving end.

No, you don’t have to learn LangChain

Mon, 21 Jul 2025 00:00:00 +0000

...or LangGraph, or LlamaIndex, or RAG, or whatever new AI-hype framework is trending this week in order build an AI-powered app.

More often than not, these frameworks are just wrappers around basic functionality—in this case, calling an API. And the layers of abstraction they introduce can make even simple things (“prompt an LLM”) feel unnecessarily complex.

Take RAG, for example. All it really does is frontload your prompt with additional context. That’s it. In practice, it boils down to concatenating a few strings—something you can do in five lines of code. But LangChain adds layer upon layer of custom methods, config objects, routing logic, etc., that often just get in the way.

Feedback is key 🔑

Sat, 19 Jul 2025 00:00:00 +0000

Back in my corporate days, I didn’t always give feedback the attention it deserves. But building poketto.me as a solo endeavour has reminded me just how crucial it really is.

Working alone has its perks: you can move fast, make bold decisions, and follow your own vision. But it also comes with pitfalls:

➡️ You get blindsided by your own past choices
➡️ You can waste time iterating on suboptimal ideas
➡️ You miss what’s obvious to others

Socket science isn’t rocket science! 🚀 Or: WebSockets + Flask + SocketIO = ❤️

Fri, 18 Jul 2025 00:00:00 +0000

For some reason, async communication between a web app backend and the browser causes more anxiety than it should (guilty 🙋). I’ve had my fair share of headaches with WebSocket frameworks before, but for poketto.me, I tried a much simpler stack—and was pleasantly surprised:

➡️http backend: Flask ( https://flask.palletsprojects.com/en/stable/)
➡️websocket backend: Flask-Socketio ( https://flask-socketio.readthedocs.io/en/latest/)
➡️websocket frontend: socketio-client ( https://www.npmjs.com/package/socket.io-client)

🔌 Backend: Handling connections is dead simple

@socketio.on('connect')
def handle_connect():
_, user_id = authenticate()
sid = request.sid
connected_clients[user_id] = sid

📤 Sending data to a connected client

sid = connected_clients.get(user_id)\
if sid:
socketio.emit('message', {
'message_type': 'save_changed',
'data': {
'id': save_id,
'state': 'archived'
}
}, to=sid)
#### **🖥️ Frontend: Receiving messages is just as easy**

const socket = io(environment.WS_BASE_URL, {

Designing for mobile after the fact is painful

Thu, 17 Jul 2025 00:00:00 +0000

I’ll admit it: when I built the frontend for [poketto.me, I focused mostly on desktop browsers—except for the reading experience, which was always meant to be mobile-first. But optimizing the rest of the UI for smaller screens later on? A real hassle—and one that could’ve been avoided had I truly embraced mobile-first design from the start.

Here are a few key lessons the hard way taught me:

📱 *Thumb-friendly design matters* The Rule of Thumbs is real:

Material’s tooltip interferes with touch-scrolling on mobile

Wed, 16 Jul 2025 00:00:00 +0000

As I mentioned the other day, I love Angular Material. However, I was quite surprised to discover that the matTooltip directive can negatively impact the user experience on mobile 🤯

I noticed that users couldn’t 'drag to scroll' on poketto.me on their phones (in both the Android app and the browser) when they started to drag particular elements on the screen, such as the save title images.

After a lot of analysis and debugging, I discovered that the matTooltip directive, which I use to render tooltips displaying the full save title in case it is abbreviated, sets touch-action: none; on that element. This means: On a mobile device, users can't start scrolling the page with that element as an anchor. It feels totally weird!

Cloud Build beats GitLab CI for my use case.

Tue, 15 Jul 2025 00:00:00 +0000

When I set up my personal blog, ralphpmayr.com, years ago, I opted for a GitLab CI pipeline to build and deploy it. However, for poketto.me, I was looking for something faster, cheaper and more closely integrated with the Google Cloud ecosystem.

I opted for Google's own CloudBuild and discovered that it integrates seamlessly with GitLab.com. In GitLab, all you need to do is create two API keys (one for read access and one for edit access), configure these in Google Cloud and CloudBuild will then be able to fetch and build any GitLab project.

The process to get an app into Google Play is… byzantine

Mon, 14 Jul 2025 00:00:00 +0000

🏗️First, of course, you actually got to build your app. Then you register at the Google Play Console (and fork over $25). Then you provide your name, contact details, etc. and then the fun starts: You need official ID (drivers license, passport), proof of residence (“Meldezettel” in Austria), proof that you own an Android device, install the Google Play Console App on that device, and verify your contact phone number.

"Token used too early" — the weirdest Google Sign-In error.

Sun, 13 Jul 2025 00:00:00 +0000

I’ve had my ups and downs with “Sign in with Google”:

⬆️It’s simple and works well on the web

⬇️It’s a complete hassle inside a hosted WebView in a native mobile app

But here’s something really funny: I local clock is ahead of Google's — sometimes by as little as a few milliseconds – the sign in call will fail with “Token used too early.” 🤯

✅ Solution: resync your system clock (in my case, my MacBook with Apple's time server).

WebView ↔ Native app communication is easier than you think.

Sat, 12 Jul 2025 00:00:00 +0000

Even without relying on the utilities provided by Capacitor, you can easily pass data back and forth between your web app and its native counterpart:

➡️In JavaScript / TypeScript you can register global functions on the window object. The native code can call these via executeJavaScript() on the WebView.

➡️In the other direction, the native code can register a JavaScript interface on the

WebView:

webView.addJavascriptInterface(new Object() {
@JavascriptInterface
public void onSessionId(String value) {
SaveUrlHandler.instance.setSessionId(value);
}
@JavascriptInterface
public void closeApp() {
MainActivity.this.finish();
}
}, "Android");

which the JavaScript / TypeScript code can call whenever it wants:

Running text-to-speech in the #Cloud is harder than you would think (part three)

Thu, 10 Jul 2025 00:00:00 +0000

So, after finally setting up a dedicated virtual machine (VM) to run my text-to-speech workloads and wiring up all the build and deployment scripts, I got a bit excited. Could I reduce the TTS latency even further if the VM had GPU power?

In theory: Yes. In practice: Google doesn't give you access to their GPUs straight away. There’s a special quota setting for VM instances with GPUs, and by default that’s set to zero. As a regular user, you cannot increase this without contacting Google Cloud Support.

Running text-to-speech in the #Cloud is harder than you would think (part two)

Wed, 09 Jul 2025 00:00:00 +0000

Do you remember when I mentioned the difficulty of running 🐸 CoquiTTS in the cloud yesterday? My first experiment was to run it directly in my Cloud Run backend service. In theory, this could have worked, but you'll never guess why it failed in practice.

x86 CPUs. Really. Like the ones we had in our computers in the 90s. How did I figure this out? After taking a horribly long time to start up, the TTS service failed with a message saying that it was running on an 'incompatible' CPU architecture. Specifically, 32-bit x86 CPUs.

Running text-to-speech in the #Cloud is harder than you would think (part one)

Tue, 08 Jul 2025 00:00:00 +0000

For the podcast automation feature that I’m planning for a future version of poketto.me, I’ve been experimenting with various text-to-speech solutions. The easiest and highest-quality approach would have been the ElevenLabs API. However, considering the “throwaway” nature of these audio files – most of which would only be listened to once by one person – and the cost structure that this would introduce, I desperately need a cheaper approach.

The Python library 🐸 CoquiTTS is pretty awesome: There are many different models to choose from, ranging from 'super low latency' to 'high quality' (including voice cloning). Therefore, poketto.me users could choose from many different voices, and from a commercial perspective, I could set different price points for different levels of quality and latency. However, they all require significant computing power to function.

Refactoring “legacy” code? Let the AI handle it!

Mon, 07 Jul 2025 00:00:00 +0000

For reasons outlined in yesterday's post, I had to switch poketto.me from #CloudSQL (MySQL) to a completely different database architecture: Firebase 🔥

At that stage, the Python backend code base wasn’t huge, but it was already fairly substantial. It included CRUD operations for several entities, as well as some basic lookup logic. Rewriting the whole thing would have taken me at least half a day.

Instead, I asked my good friend #Claude to take care of things. And, to my surprise, the result worked straight away! 🎁The “dorp in” replacement generated by the AI immediately passed my unit tests, and also the chatbot’s instructions for how to set up and configure #Firebase were actually useful.

CloudSQL is prohibitively expensive (at least for small projects)

Sun, 06 Jul 2025 00:00:00 +0000

When I started setting up the cloud infrastructure for poketto.me, I didn’t give much thought to costs. I thought it was such a small project that it just wouldn’t matter. I launched a #CloudSQL (MySQL) database with pretty much the default settings and was quite happy with it – until I checked the billing dashboard a couple of days later and realised that I was already spending almost €4 per day on the database alone. 120 euros per month just for a few MySQL tables? That couldn’t be right.

There’s no “npx cap remove” 🤦‍♂️

Sat, 05 Jul 2025 00:00:00 +0000

#Capacitor comes with a user-friendly command line interface. To add a new mobile platform to your project, simply run “npx cap add [android | ios]”. And to remove one? Exactly — you guessed it: 'npx cap remove...' But: That command isn’t implemented – for understandable reasons. The interesting thing is, though, that it's "plausible" that it would be there, right?. So it's not surprising that #Claude insists it exists.

This once again highlights a major issue with LLMs that I just can’t shut up about: Just because what the chatbot says sounds 'plausible' doesn't mean it's correct. In the case of AI-assisted coding, that’s not such a big deal – you, the developer, will eventually realise that the AI was wrong. But what about the many other use cases where we blindly trust the AI and put whatever it says into action? 🤔

Multi-threaded webservers in Python: A rabbit hole you don’t want to get into.

Fri, 04 Jul 2025 00:00:00 +0000

Put simply, serving web requests properly in Python is not easy. poketto.me uses a fairly basic off-the-shelf stack (#Flask as a web framework and #SocketIO for websocket communication), and you would never guess the issues you could encounter with it. For starters, Flask comes with a built-in web server (“werkzeug”), which is convenient for development, but absolutely not for production (it even warns you in bright red).

🧵It runs on a single thread – I'm not kidding. This means it can only handle one web request at a time. If that request involves any actual work, such as extracting web content, it cannot handle any other requests at the same time.

Building a Chrome Extension is easier than I thought — but still a bit of a hassle

Thu, 03 Jul 2025 00:00:00 +0000

To my surprise, building a Chrome Extension is technically quite straightforward. You need:

A bit of HTML (the popup UI)
A bit of JavaScript (your logic)
And a $5 one-time fee to publish in the Chrome Web Store

The Chrome Extensions API is pretty minimal, but it covers all the basics:

✅ You can persist data (e.g. auth tokens)
✅ You can query open tabs, grab the current URL
✅ You can even inject JavaScript into pages — though this last bit triggers stricter review from Google, especially if you request broad access (like "<all_urls>").

Extracting web content is still… messy.

Wed, 02 Jul 2025 00:00:00 +0000

You can talk about autonomous #AIAgents roaming the web and performing all kinds of tasks 'just as a human would' as much as you like, but technically, some of the very basics are still lacking. For example, there is no free, easy-to-use, off-the-shelf solution for extracting web content.

Here’s what I mean: Think of poketto.me as a very basic 'agent': you tell it to save a URL, and then it talks to the website 'on your behalf' to access its content. For this use case, the Newspaper3k Python library is pretty good: it teases out structured metadata, but occasionally misses basic things like the content language. To retrieve the actual content, Trafilatura ( https://github.com/adbar/trafilatura) appears to be the best option at the moment. However, even that doesn't work well with all sites. For edge cases, I actually had to fall back on parsing the raw HTML myself using Beautiful Soup ( https://beautiful-soup-4.readthedocs.io/en/latest/). (And yes, I’m sending that through an LLM later to streamline the content so all the tiny formatting issues Trafilatura introduces get smoothed out again.)

Hybrid apps & social logins: tread carefully.

Tue, 01 Jul 2025 00:00:00 +0000

Remember when I talked about “Sign in with Google?” That works really well on the web, but: Once you’re wrapping your web app into a native mobile app, things turn very ugly very soon. In a hosted WebView, Google won’t let you render the sign in button to begin with – unless you override the WebView’s user agent string. After that, you’re still screwed if you rely on the default sign in workflow as this would open a popup window from which the user then can’t navigate back into your app.