Yeldar Kudaibergen – directflow

DirectFlow App – follow podcasts directly

Yeldar Kudaibergen — Thu, 14 May 2026 17:00:00 PDT

I’ve been experimenting with a small project called DirectFlow.

Right now it looks like a simple podcast app, but the original idea behind it was actually much broader. At first, DirectFlow was an experiment around the idea that people should be able to follow websites directly, without depending so heavily on platforms, directories, or centralized systems in between.

The idea was simple: paste almost any website URL into a form, and the application would try to discover machine-readable flows directly from the website itself. RSS feeds, Atom feeds, JSON feeds, and other things websites already expose in their HTML metadata.

But while building it, I realized something important: most people do not naturally think in terms of “following websites directly.” It is still not a familiar user experience outside of a few technical communities.

Podcasting, however, immediately stood out as a place where this problem is very real.

Subscribing to podcasts today is still strangely complicated compared to the rest of the modern internet. Usually you need to search inside a specific app, rely on podcast directories, or manually deal with RSS feeds that normal users were never supposed to think about in the first place.

At the same time, the underlying infrastructure already exists and already works surprisingly well. Most podcast websites already expose feeds automatically. RSS already works. Open podcasting already works. The problem is mostly the user experience around it.

So I decided to intentionally narrow DirectFlow down to podcasts for now.

Today the idea is intentionally simple: you paste a podcast website URL into DirectFlow, scan a QR code, or share a link into the app — and DirectFlow automatically discovers the podcast feed and subscribes you to it.

No searching through directories.

No explaining RSS.

No copying feed URLs manually.

No platform lock-in.

Just follow the podcast directly from its website.

The current version is still very experimental, but it already supports both audio and video podcasts. If a feed contains playable audio or video enclosures, DirectFlow can detect them and play episodes directly inside the app.

At some point I also realized that my own definition of podcasting had become much simpler than many industry discussions around it. To me, a podcast is basically just an open feed with playable enclosures. That’s it. If a feed contains playable audio or video files, applications should be able to discover it, subscribe to it, and play it.

I also started using the word “flow” instead of only “feed,” because it feels broader and more correct for what I’m experimenting with. A feed is a technical format. A flow is more like a relationship between a website and an application.

Some of these ideas later evolved into another small project called QRX, which experiments with discovering machine-readable flows from normal URLs and QR codes. I wrote a bit more about that separately already.

Right now DirectFlow is mostly a place where I experiment with podcast UX ideas in public. Maybe some of these ideas eventually become part of a bigger standalone application. Maybe some of them simply help existing podcast apps become better.

Either way, I think podcast subscriptions should feel much more natural than they do today.

I’ve been working with podcasts for many years now, both technically and creatively, and one thing I’ve seen again and again is how much friction still exists around subscriptions.

I’ve had to explain RSS feeds to listeners countless times. I’ve had to explain how podcast apps work, how to copy a feed URL, where to paste it, why some apps behave differently, why searching sometimes fails, why a podcast appears on one platform but not another, and so on.

And every extra step loses people.

You can literally watch listeners disappear during the subscription process. Someone gets interested in a podcast, but before they actually subscribe, they already have to understand too many things that normal users should never have to think about. RSS feeds, directories, platform differences, search indexing, manual imports — all of this still leaks into the user experience.

That’s one of the main reasons I started building DirectFlow.

And honestly, I think I may have finally found a very simple solution to this problem.

Imagine if podcast apps like Pocket Casts, Apple Podcasts, Fountain, Overcast, or others simply added a QR scanner inside the app itself. A person scans a QR code from a podcast website, poster, video, or screen — and the app immediately discovers the podcast feed and subscribes them natively.

Or imagine someone simply pasting a podcast website URL into a podcast app, and the app instantly showing the podcast page and follow button automatically, without requiring the user to understand RSS at all. That changes the entire subscription experience.

The really interesting part is that subscriptions would finally happen directly through the podcast’s actual open feed itself, instead of depending entirely on platform-specific IDs, internal databases, or centralized discovery systems.

The infrastructure already exists. Most podcast websites already expose their feeds publicly. Applications simply need to discover and use them more naturally. I think it will be very interesting to watch how podcast subscriptions evolve from here.

Podcasting has been a huge part of my life for a long time. I’ve created podcasts myself, worked with podcasters, built podcast-related tools, explained podcast infrastructure to companies and creators, and spent years thinking about how open podcasting actually works underneath the surface.

I’m even writing a book about podcasting right now because I think there are still many things about this medium that people outside the industry do not fully see yet.

That’s also why DirectFlow is not just a random experiment for me. It comes from years of seeing the same UX problems repeat over and over again, and finally trying to build a simpler approach around the infrastructure podcasting already has.

QRX means Quick response experience

Yeldar Kudaibergen — Thu, 14 May 2026 17:00:00 PDT

Right now I’m working on the idea that people should be able to follow sources directly, without platforms or intermediaries in between. And this is already possible. You can already subscribe to podcasts through DirectFlow.

Originally, I built DirectFlow so that a person could paste almost any website URL into a form, and DirectFlow would immediately discover the main flow of that site and subscribe to it. I started using the word “flow” because it felt broader than just “feed.” A feed is more of a technical format. A flow can also represent other machine-readable relationships.

At some point I started thinking: what if a user simply scanned a website QR code, and DirectFlow instantly subscribed them to it? After all, DirectFlow already discovers the main flow of a website just from its URL. The system does not really care how that URL arrives - whether it was pasted into a form, shared from another app, typed manually, or... scanned from a QR code. That was the moment everything clicked.

I realized I had accidentally solved one of the fundamental UX problems of podcasting: subscription. Suddenly, subscribing to a podcast could become as natural and lightweight as following someone on social media for the first time.

Then I started looking around to see who else was thinking about QR codes this way. There were hints of similar ideas, but almost all of them had the same limitation: a QR code always triggered one fixed interpretation or one predefined action.

In my case, the QR code itself stayed completely unchanged, but what applications could discover from it was no longer limited. If a website exposes machine-readable flows in its HTML head or HTTP headers, then different applications can discover completely different things from the exact same URL.

For example, https://example.com may expose a podcast RSS feed in its head metadata. If a podcast player scans that website QR code, it can automatically discover the feed and immediately offer the user a native “Follow podcast” experience. This scenario already works in DirectFlow using the QRX JavaScript SDK. That was the moment QRX became a separate project outside of DirectFlow.

About the name. At first, the working name was QR-UX, because this idea is really about changing the user experience around QR codes without changing the QR code itself or the existing web infrastructure behind it. The QR code, the URL, and the website all stay the same. What changes is the experience applications can provide after scanning. Later the name became QRX. And eventually I realized it could naturally stand for Quick Response Experience, because that is exactly what this approach changes: the experience of interacting with QR codes and URLs.

I’ll continue writing about QRX here. Over the last week I’ve accumulated quite a lot of thoughts, observations, and already a bit of real implementation experience.

Learn programming through undestanding

Yeldar Kudaibergen — Sat, 09 May 2026 17:00:00 PDT

Sometimes I think about writing a blog post and then suddenly it feels like: “this is so banal”, “who would even care about this, let alone find it useful.” But still, let me try to explain what I’m experiencing right now in my programming journey.

It’s strange. I realized that even though I already built ProxyFeed (backend in TS), it feels like I’ve never actually programmed before. It turned out that, in my current understanding, programming is when you write code yourself and run the program to see whether it works or not. And a person becomes a programmer exactly at that moment. A professional programmer becomes one when somebody pays them for it — usually money, by agreement.

So yeah, I came up with something again. And I’m 100% going to build it. It’s one of those “projects” that simply deserves to exist, and my buddy confirmed it too. The funniest and most dramatic part is that I literally cannot not build it. So yes, in a more or less sane state of mind, I’m voluntarily getting myself into this story. Let’s see what happens.

Even though I had never written a single line of Go in my life, I decided that Go would become the main backend language for DirectFlow. I looked at the situation from many different angles and it seems that, at this moment, Go is the most suitable language for me. I even realized why. It’s strange to understand the difference between TypeScript and Go not only through syntax, but through the character, logic, explanations, and style of the language itself.

I was immediately surprised that := in Go means both creating and assigning a value. Previously, I had creation and assignment both through =, meaning one action represented two completely different things. Anyway, I liked Go because it feels like the language is built similarly to how I am as a person. I don’t fully understand it yet myself, but I like that it works.

My next realization is that we learn programming by doing it. By writing code, creating programs, and running them. Previously, it felt to me like first you learn, and only then you program. As if you cannot program until you’ve learned how. Sounds logical, right?

But here’s what I discovered: computers do not grow naturally like trees. Humans created computers, languages, and embedded their logic into them. Our job is simply to understand how things work — not memorize syntax. Then write code. Realize why it's wrong I mean error. Again and again. That’s it.

But here’s what I discovered: computers do not grow naturally like trees. Humans created computers, programming languages, and embedded their logic into them. Our job is simply to understand how things work, not memorize syntax. Then write code. See why it’s wrong, fix the error, understand it. Then write code again. Again and again. That’s what a developer’s job is, right? And apparently, this is how a person becomes a programmer. You simply write code, understand it, and when you run the program — you are a programmer.

I partially understand that the “writing code” part may sound old-fashioned now, especially when it feels like AI writes code for everyone. But this is my current understanding, and I’m sure it will evolve further. And I will definitely keep writing about it here.

Follow my blog directly on DirectFlow: https://directflow.app/follow?url=https://yeldar.org