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.

Automating Instagram is a nightmare!

Sun, 05 Oct 2025 00:00:00 +0000

This one isn't entirely related to poketto.me, but it's still an interesting lesson I learned the hard way the other day: If you want to build a "simple" app that automatically posts content to your Instagram account, it's much more difficult than you'd think.

First, there's a GitHub project called instagrapi that seems to offer a nice Python automation library for Instagram. It can post photos, videos, etc. Looks good, right? Don't use it. Ever. It’s based on unofficial APIs, and using it — especially in a script running in a cloud environment — will get your Instagram account blocked almost instantly.

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.

Use virtue signalling (but only if you’re actually planning to be virtuous!)

Wed, 01 Oct 2025 00:00:00 +0000

In Use friction to your advantage, I talked about ways to nudge users toward desired—or away from undesired—behaviours. Take this idea too far, however, and you end up with Dark Patterns: UI tricks that deliberately deceive users.

E-commerce is full of bad examples:

– The “Only 3 Left In Stock!” badges that try to rush you into a purchase

– The awkward games and bonus points on the Temu app

– Cookie consent banners where the “Accept all” button looks like the only real option

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?

Use friction to your advantage

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

Amazon in general, and Jeff Bezos in particular, are famous for “reducing friction.” Case in point: One-click checkout. Allegedly, it was Bezos himself who obsessed over removing as many steps as possible from the customer’s path to purchase. Enter your shipping address? Confirm your credit card number? Validate the details? Gone. Just “Buy now,” and the goods will be in your mailbox tomorrow.

For poketto.me, I applied this principle to the signup process. What’s the simplest way to enroll for a new product or service? Do you really want to enter your name (first and last), email address (twice), a password (with arbitrary security criteria), then get a confirmation mail, click the link, and finally find yourself in another browser tab (or window)? By that time, many users would surely have given up.

Google’s Play Store review process is pure torture

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

In TIL #14, I called getting an Android app into the Play Store “byzantine.” Turns out, I was being too generous to Google and too strict on the ancient kingdom of Byzantium.

Here’s what really gave me headaches over the last few months:

🤕 Headache #1: The forms

Before Google even looks at your app, you’re drowning in bureaucracy: ticking the “my app doesn’t process health data” box 12 times, pasting links to T&Cs and privacy policies, verifying your name, intentions, identity, blood type, shoe size, the maiden name of your mom’s dog, …

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/)

AI can’t replace a great marketing team (but sometimes it’s better than nothing)

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

Marketing done well is so much more than cranking out ad copy or polishing sales slides. In all my corporate product roles—Fabasoft, Borland / Micro Focus, smec—I got to work with fantastic marketing teams. They shaped products, challenged ideas, and saw the bigger picture we tech-focused product folks often missed.

With poketto.me, though, it was just me. So I leaned on ChatGPT, Grok, and Gemini more often than I liked—sometimes with good results, sometimes… not so much.

Klaviyo: Much more than a Shopify plug-in

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

As I mentioned in GMail’s spam filter is pretty weird, reliably sending emails is harder than it looks. But email marketing automation is also one of the most powerful tools you can add to your stack.

So, I went looking for a simple, cheap, API-based solution I could plug into poketto.me. Ideally:

✔️ Free for small usage (given my current revenue = zero)
✔️ Easy integration with my stack existing stack (Python backend, Posthog for analytics)
✔️ Scalable once I need more

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:

LinkedIn isn’t working

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

For the last 91 days, I’ve posted one of these “things I learned when building poketto.me” every day here on LinkedIn. What was my motivation for that?

1️⃣ To reflect more deeply on the countless things I’ve learned. Think of it like a gratitude journal: by writing down the small technical quirks, process hacks, and organizational lessons, I hoped to make them stick better.

2️⃣ To help others avoid some of the many mistakes I've made.

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!

How to plan a time-based launch 🚀

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

Since early August, I’d been toying with the idea of taking poketto.me “out of beta.” But with travel planned for late September through mid-October, timing became critical. I needed to launch before leaving, so I set “early September” as the latest possible date—giving myself at least two weeks to handle any post-launch chaos.

The first question I asked: What does “launch” actually mean? What’s different afterwards?

Here’s what came to mind:

Pricing: 🎨 Art + 🧪 Science + 🪄 Alchemy

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

Finding the right price point—for anything—is part science, part art, part alchemy… and maybe a sprinkle of luck.

Charge too little, and you leave money on the table. Charge too much, and you don’t close the deal. This trade-off is as old as commerce itself, but it’s especially tricky for intangible products like software—particularly when selling subscriptions instead of one-offs and purely product-led (without the benefit of a human sales manager in the loop).

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.

The freemium trap (or why free trials don’t work)

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

Let’s face it: It’s hard to get a freemium model right. While thinking through pricing and packaging for poketto.me, I looked at a lot of other B2C apps—and most of them had some flaw, inconsistency, or irritation in their approach.

One striking example is Strava. The fitness app is wildly popular (150M+ users worldwide) and valued at $2.2B. But their free-to-paid conversion strategy seems to be struggling. Why?

👉 The core value (activity tracking) is fully commoditized, with little room to differentiate (Garmin Connect, Nike Run Club, Apple Health, etc. essentially all do the same thing).

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.

Define what ‘done’ looks like (and stick to it!)

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

Working solo on poketto.me — without the built-in “pressure to deliver” that comes with a corporate environment — comes with an interesting challenge: actually shipping stuff.

Here’s an example. When I started building the “Share…” feature, I had something super simple in mind: users should be able to create shareable links to their content, which others could view on poketto.me without logging in. I figured this would create a self-reinforcing loop: existing users share content → new people enjoy the clean, distraction-free reading experience → they sign up → save their own content → share it → and the cycle continues.

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).

It’s more than a marathon

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

I promise I won’t turn into my Strava feed. But there’s something to be said about the similarities between running long distances and building products.

You’ve probably heard the “it’s a marathon, not a sprint” metaphor before — but I want to add one more twist.

You can approach running a marathon in very different ways. Some people go from zero-to-marathon in 12 weeks of intense training. It’s doable, but those gut-wrenching training plans… you really don’t want to go through that. And often, this results in a once-in-a-lifetime, superhuman effort. It looks hard. It feels hard. Sure, you can pat yourself on the back afterwards if you make it — but the risk of injury is high, the odds of repeating the feat are low, and the long-term benefits are minimal.

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.)

Show. And Tell. And Write.

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

The other week, a post by someone at Google went viral. The gist: PMs should focus on building prototypes that show what the product is supposed to do, rather than merely telling through written PRDs.

That resonated with me.

As a developer-turned-PM, I always found it limiting that “building” was considered out of my scope. I got to write specs, user stories, and requirement docs — but those often failed to capture the intent behind an idea, leading to botched execution of a feature. A lot got lost in translation.

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.

State diagrams are fun!

Mon, 25 Aug 2025 00:00:00 +0000

One would think that poketto.me is so straightforward that any kind of architectural documentation would be unnecessary. But then...

Whenever a user saves something, the app first fetches the raw content from the relevant webpage. Then, the content undergoes an asynchronous 'cleanup' process (as I mentioned previously, I use an LLM to fix broken formatting, etc.). If the user has turned on that setting, the content is then translated. This already results in five different states that a Save can be in: New (no content available yet), Extracted (raw content available), Processing (raw content cleaned up), Translating (content being translated), and 'None' (everything done). Of course, the frontend needs to be mindful of what to allow the user to do in each of these states.

UX details sometimes make all the difference

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

In WebSockets: More than tech vanity, I talked about how poketto.me uses WebSockets to keep the UI in sync with async backend processes—like translating, TTS, etc. Neat? Sure. Game-changing? Probably not. Just like I asked about AI in AI is not a value proposition: where would you put that on the Business Model Canvas? It doesn’t really fit as a Value Proposition, does it?

But that doesn’t mean it’s not important. Take Strava, for example.

AI is not a value proposition

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

I didn’t coin this phrase (sadly), but it keeps proving itself true—especially now that I’m working on GTM details for some of the more advanced features in poketto.me.

Most users don’t care how your app works. They care what it does for them—and whether that’s worth paying for.

Since LLMs became easy to embed, companies started slapping “powered by AI” stickers on everything as if that alone justified a price tag. But unless the user clearly feels the value, it doesn’t matter what's under the hood. Case in point: Garmin’s hilariously underwhelming $7/month “AI subscription”. The so-called “insights” offered nothing users couldn’t deduce themselves—or the app couldn’t have generated with much simpler logic.

Passion is what gets you started…

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

You’ve heard it before: It’s a marathon, not a sprint. That’s true for almost everything worthwhile—learning a new skill, building healthy habits, nurturing relationships… and yes, building, maintaining, and growing something like poketto.me, even if it's “just” a side project.

Psychologist Angela Duckworth frames this through the lens of grit—not sheer willpower (which is fleeting and highly dependent on external factors), but the combination of passion (what gets you started) and perseverance (what keeps you going).

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?

How to (not) do paywalls

Mon, 18 Aug 2025 00:00:00 +0000

As I pointed out a few weeks ago: The web, as it's designed today, is not ready for “Agents” of any kind—AI-driven or just plain old automation scripts. Why? Because there’s no agreed-upon way for machines to interact with websites on behalf of a user.

Case in point: Paywalls.

Publishers are getting more creative in protecting their content from scraping, and rightly so: no one wants their work stolen by AI companies or repackaged by Google. But at the same time, they want to provide a good user experience for those who pay.

Tackle the Monkey First

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

I don’t remember where I first came across this metaphor, but I still love it:

Suppose your task is to train a costumed monkey to recite a Shakespeare sonnet while standing on an elaborately carved wooden pedestal. Where do you start? Do you begin by picking out the wood for the pedestal? Designing the decorative motifs? Choosing which hat the monkey should wear? Or—more obviously—do you first figure out whether you can actually get a monkey to recite poetry in the first place?

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.

Know When to Maximize—and When to Satisfice

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

Just like optimism vs. pessimism, there's another spectrum that every builder, founder, or product person lives on: Maximizing vs. Satisficing.

In behavioral economics, a maximizer tries to achieve the best possible outcome. For example: spending hours to find the absolute best hotel for your vacation. A satisficer, on the other hand, picks the first option that meets their basic requirements—and moves on with their day.

When developing products, it's incredibly useful to know where you fall on that scale because: There’s not simple answer when to apply which strategy.

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.

The Optimism Trap (and Why You Need Its Opposite)

Mon, 11 Aug 2025 00:00:00 +0000

I just finished The Bright Side by Sumit Paul-Choudhury—a solid deep-dive into the history, psychology, and applicability of optimism. The social science is clear: overall, optimists tend to achieve better outcomes.

Why? Because they act. Optimists move toward a positive vision of the future, and in doing so, often stumble upon unexpected opportunities. Pessimists, by contrast, lean toward fatalism and inaction — and the world rarely arranges itself in exactly the way they’d like, anyway.

Keep a List of ‘Low-Hanging Fruit’ for Days You’re Not Feeling It 🍒

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

One of the perks of working independently on an early-stage product is flexibility — but that comes with a risk: running out of steam. Like I said in my post about #pacing, it’s key not to overextend on the good days and not to check out completely when the work feels like a slog.

One trick I’ve found increasingly helpful as the codebase grows? Keep a backlog of quick wins:

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.

Consistency Beats Accuracy (Part 1)

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

As I add more UI-heavy functionality to poketto.me (not all of it public yet), I keep running into the same issue: it’s tempting — but risky — to constantly invent new UI patterns and elements.

Case in point: On the Saves page, each saved item has a “more” menu with actions like Archive, Delete, or Edit Tags. But when I worked on the News Feed, I completely overlooked this. Instead, I gave each news item its own action bar — dedicated buttons to save the item or, once saved, edit its tags. (See Exhibit A.)

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.

Know When to Explore — and When to Build

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

As I dive deeper into poketto.me, I keep running into an increasingly tricky question:
How much time should I spend exploring new features — and how much actually building them?

Having worked as a Product Owner, Manager, and Director, envisioning exciting new features comes naturally. And with poketto.me, the possibilities seem endless:
🎧 Personalized podcasts
🗞️ AI-curated newsfeeds
📝 Automatic summaries
📬 Individualized daily digests
🖊️ Highlights, annotations, organization tools
🔍 Full-text search and even personal knowledge management (PKM)

LLM-Based Translations: The Good, the Bad, and the Ugly

Mon, 04 Aug 2025 00:00:00 +0000

Automatic content translation has been a key feature of poketto.me from day one. Why? Because I believe there’s immense value in making content accessible to non-native speakers.

Personally, I’m deeply interested in developments in countries like India, Pakistan, and China — but the best publications from those regions often don’t publish in English. Being able to read and compare both Dawn News (Pakistan) and the Hindustan Times (India) coverage of tensions between the two countries — in English — for example is fascinating.

‘Cloud Idenity’ is a secret well kept by Google

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

Permissions on Google Cloud resources are assigned to principals. Principals, in principle 😏, are Google accounts. My personal @gmail.com address, for example, is the principal that "owns" most of my Google Cloud stuff. So far, so good.

However, in some cases, I was required to delegate ownership of a resource to a principal with an @poketto.me email address — a domain for which I don’t have a Google Workspace account. Consequently, these addresses aren’t recognized as regular Google Accounts. (See exhibit A)

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.

Pace yourself!

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

Working on a substantial project without real external pressure — deadlines, financial run rates, etc. — comes with a huge risk: you can easily run out of steam.

When your only driver is your own motivation, you have to manage that resource wisely. Case in point: when I started tinkering with poketto.me, I thought I’d just replicate Pocket’s feature set and be done within four weeks. Initial success came quickly — things worked the way I’d hoped, the UI kept getting better, AI coding tools helped kick-start the boilerplate work on infrastructure… But then I started slacking off. I kept postponing work on the Chrome extension, the website, or the GTM strategy, and turned my attention to other side hustles instead. The initial drive I’d had simply faded.

No, AI will not take McKiney or BCG out of business any day soon

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

Despite what the “God of Prompt” (sic!) or any other self-proclaimed “AI expert” is trying to tell you, none of the current AI models will replace a multi-hundred-thousand-dollar product strategy project.

First of all, the people making these claims are, most likely, just trying to sell you their overpriced list of “magic” prompts — and hoping for endorsement from the big AI companies or a retweet from Elon Musk.

But giving the AI tools the benefit of the doubt, I tried using Grok, ChatGPT, and Claude to iterate on a commercial strategy for poketto.me. The results were… disappointing. Here are the main issues:

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**.

Good things come to those who wait ⏳

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

Remember when I was complaining about how hard it is to run even basic ML workloads on GCP? Turns out, Google has listened 😊 (well, probably not to me personally, but in general).

You can now request GPUs for Cloud Run instances in the UI as well as on the command line. That means all the hassle I went through deploying my text-to-speech service into a Docker environment running inside a preemptible VM with GPUs—and then figuring out how to start, stop, and deploy the VM automatically—was… well, not exactly wasted, but at least: not necessary anymore.

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)?

For non-urgent LLM tasks, DeepSeek has offers great value for money

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

AI is not at the core of what poketto.me does, but it helps a lot: I’m using LLMs to translate saved content and to smooth out formatting issues (especially with PDF content). Any old LLM can do these things quite well, but when it comes to pricing, none beats DeepSeek.

When using their API, processing a million input tokens can be as cheap as $0.035, and a million output tokens will cost you at most $1.10. To give you an example: A typical 1,500-word essay will come down to about 2,000 tokens (input and output combined).

Never trust ChatGPT

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

I may sound like a broken record on this, but I’ve seen it over and over again while working with AI tools on poketto.me: Don’t trust the chatbots. Ever.

ChatGPT in particular has two immense problems: sycophancy and accuracy.

Regarding the former: It’s trying to please you—the user—to the point where it feels like every response is prefaced with a compliment that’s only designed to keep you engaged. Some examples?

Scaling down screen recordings with ffmpeg is fast, easy, and super useful

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

I use the free version of Monosnap to record short feature videos for poketto.me—the ones I post here, on X, and on Bluesky. It works great, but the default encoding produces videos that are far too large for other contexts—especially email.

Rather than fiddling with different encodings, I use the command-line tool ffmpeg to scale down the videos. A typical Mac screen recording often has dimensions well over 2000×1500 pixels—when half (or even a quarter) of that would easily do the job.

Don’t attach yourself to outcomes

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

This one’s a bit more philosophical—but stay with me: There are things in life we can control, and things we can’t. That distinction lies at the heart of Stoic philosophy, most famously articulated by Epictetus in the first century BC.

What does that have to do with product development?

A lot, actually.

When you’re working on a small, independent project like poketto.me, it’s easy to grow frustrated with a lack of resonance. LinkedIn posts don’t get the traction you hoped for. Journalists don’t reply. Mozilla doesn’t respond, even after you’ve tried to nudge them on all imaginable platforms,. It can feel like you’re putting something good into the world—and the world is simply ignoring it.

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.

High-quality screenshots? is your friend! 🖼️

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

Taking good screenshots of a web or mobile app is an art in itself:

🤨Which screens do you show?
🤨What demo data should appear?
🤨How much (or how little) functionality and complexity do you reveal?

For poketto.me (the landing page), I chose a fairly minimal set of screens. But I still wanted them to look polished—whatever that means.

Turns out, BrowserFrame.com makes this super easy:

➡️ Upload a raw screenshot of your app
➡️ Pick from a range of realistic browser window styles (Chrome, Safari, Edge, etc.)
➡️ Download a slick, framed version—complete with browser chrome and a subtle drop shadow

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:

The Noah-principle (still) doesn’t work

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

“Build it and they will come” is allegedly what God told Noah when he wondered how all the animals would find the ark.

As builders, we often fall into the same trap — assuming that once the product is done, users will magically appear. And when they don’t, it’s not just disappointing — it’s exhausting and demotivating.

Turns out, even launching something small (like poketto.me) requires way more go-to-market work than expected. And honestly? That part’s less fun than building.

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.