Building MicroStream: A Weekend Experiment with Micropayments
What happens when you try to build pay-per-second payments in 48 hours
Building MicroStream: A Weekend Experiment with Micropayments
What happens when you try to build pay-per-second payments in 48 hours
The Weird Problem I Stumbled Into
I signed up for this hackathon called “Qubic Hack the Future” (December 5-7) without really knowing what I was getting into. Qubic is a blockchain - the technology behind cryptocurrencies like Bitcoin - that claims to have zero transaction fees and can handle 15.5 million transactions per second. Cool, I guess? But I had 48 hours to build something and no idea what.
So I started researching. What kinds of apps make sense on a blockchain? What problems could this actually solve? That’s when I kept seeing “micropayments” mentioned everywhere as this holy grail feature. The idea is simple: what if you could pay someone a fraction of a cent for something? Like paying $0.001 to read one article, or $0.30 to watch 10 minutes of a video?
Sounds useful, right? But then I noticed something odd: nobody was actually doing it.
Turns out there’s a pretty simple reason why. When you want to send money on most blockchains, you have to pay a “gas fee” - basically a transaction fee that goes to the people running the network. On Ethereum (the biggest blockchain for apps), that gas fee is around $5 per transaction. So if you want to send someone $0.001… you’d pay $5 to move it. You’re literally paying 5,000 times more in fees than the actual payment.
That seemed broken. Like, fundamentally broken. But then I remembered: wait, Qubic claims zero fees. Could micropayments actually work here?
I had 48 hours to find out.
The idea I landed on was simple: what if you could pay for streaming content by the second? Not per month like Netflix. Not per video like YouTube rentals. Literally per second of watching. So if you watch 87 seconds of something, you pay for exactly 87 seconds. Not 90. Not rounded up to a minute. Exactly what you consumed.
I decided to called it MicroStream.
What I Actually Built
MicroStream is basically pay-per-second streaming. You deposit some money (in this case, QUBIC cryptocurrency) into a “payment channel” - think of it like putting cash in a parking meter. Then you start watching content, and every single second, a tiny amount gets deducted. When you stop watching, you instantly get your remaining balance back.
The part I’m most excited about is the live counter. When you’re watching, you see three numbers updating every single second:
Seconds Watched: starts at 0, ticks up (1, 2, 3, 4…)
Amount Paid: starts at 0.000 QUBIC, ticks up (0.001, 0.002, 0.003…)
Remaining Balance: starts at 10.000 QUBIC, ticks down (9.999, 9.998, 9.997…)
Watching all three numbers tick in sync is weirdly satisfying. It’s one of those things where you know intellectually that “blockchain is fast” but seeing it update every single second makes it click.
How It Works (Non-Technical Version)
Let’s say you’re looking for a new streamer to watch. Streamers can set their rate at 0.001 QUBIC per second (which is like a fraction of a cent). You deposit 10 QUBIC into the system - think of it like putting $5 into a prepaid account.
You click “Start Watching” and you begin watching the new streamer you picked. Every second that ticks by, 0.001 QUBIC gets added to the “amount paid” counter. After 10 minutes (600 seconds), you’ve paid 0.600 QUBIC - roughly 30 cents. But maybe you only needed those 10 minutes, not the full 5-hour stream. So you click “Stop” and immediately get your remaining 9.4 QUBIC back.
The streamer, on their end, sees the earnings accumulate in real-time. They can claim their 0.600 QUBIC whenever they want. No waiting for monthly payouts. No minimum threshold. No platform taking a 30% cut. They just… get paid for exactly what you watched.
This all happens through what’s called a “smart contract” - basically a program that runs on the blockchain and enforces the rules automatically. The contract keeps track of how long you’ve been watching, calculates how much you owe (seconds × rate), and makes sure neither person can cheat the other.
Why This Needed Qubic Specifically
Here’s the thing: I didn’t choose Qubic because I’m some blockchain expert who evaluated 50 different chains. I chose it because the hackathon was for Qubic. But it turned out to be the only option that actually made this work.
Let me show you the math. Imagine a 1-hour stream where the counter updates every second. That’s 3,600 transactions (one per second for 60 minutes).
On Ethereum, each transaction costs about $5 in gas fees. So 3,600 transactions × $5 = $18,000 just in fees. To watch a one-hour video. Completely absurd.
On Solana (another blockchain known for being “fast and cheap”), fees are much lower - maybe $0.0002 per transaction. That’s 3,600 × $0.0002 = $0.72 in fees. Way better than Ethereum, but still, you’re adding almost a dollar in fees for something that might only cost you a few dollars to watch.
On Qubic? Zero. The fees are literally zero. So 3,600 transactions × $0 = $0 in fees.
That’s not just “cheaper.” It fundamentally changes what’s economically viable. Suddenly you can charge someone a penny for something without losing half of it to fees. You can update a counter every single second without bleeding money.
I didn’t pick Qubic because it’s “better” - I picked it because the hackathon was about Qubic and I got lucky that it happened to be the only chain where the math works for this idea.
🤷♂️
What This Could Enable
I keep thinking about use cases beyond just streaming videos.
Imagine you’re a student who wants to learn Python. There’s a 10-hour course online, but you’re not sure if it’s any good. With traditional subscriptions, you’d pay $50 upfront and hope for the best. With MicroStream, you could pay 0.001 QUBIC per second, watch the first 20 minutes (costing you about 10 cents), and decide if it’s worth continuing. If the course sucks, you only lost 10 cents instead of $50.
Or imagine you’re a developer trying out a new API (a service that lets apps talk to each other). Most APIs make you commit to a monthly plan - maybe $99/month for 10,000 API calls. But you just want to test it out with 50 calls to see if it even works for your use case. With per-call micropayments, those 50 test calls might cost you 5 cents instead of $99.
Or a musician performing a live-streamed concert. Fans who stay for the whole hour pay the full price. Fans who just want to hear their favorite song and then leave pay for 5 minutes. Everyone pays exactly what they consumed. No all-or-nothing paywalls.
I’m not saying any of this will definitely happen. But it’s interesting to think about what becomes possible when transaction fees stop being a constraint.
The 48-Hour Build
I’ll be honest: the first 12 hours were rough. I had to learn what smart contracts were and how to write them in C++ (Qubic’s programming language), understand how payment channels work, and figure out all the edge cases. What happens if someone’s balance runs out mid-stream? What if they try to close the channel while still watching? What if the creator tries to claim more than they’re owed?
The backend took another few hours. I built it in Node.js (a JavaScript framework for servers) and added something crucial: a “demo mode” that lets you test everything without actually deploying to the blockchain. This saved me so much time because I could iterate quickly without waiting for blockchain confirmations.
Then came the frontend - the part you actually see in your browser. The live counter was surprisingly tricky to get right. I needed all three numbers to update at exactly the same time, stay in sync, and handle pausing/resuming correctly. I kept it simple with vanilla JavaScript (no fancy frameworks) because I was running out of time.
The last few hours were a scramble. Documentation, demo video, testing, fixing bugs I found during testing, more documentation. I submitted with 1 minute to spare.
What I Learned
The biggest surprise was how much the demo mode mattered. Being able to test without deploying to the blockchain meant I could iterate in seconds instead of minutes. Every time I found a bug, I could fix it and test immediately instead of waiting for blockchain confirmations.
The second surprise was how much the UI matters. I’m a backend person - I like writing the logic and making things work. But the live counter ended up being the feature that makes people immediately understand what MicroStream does. I probably should have built that first and validated the concept before spending hours on the smart contract.
Working with AI (Claude Code, specifically) was also interesting. I’d write out what I was trying to build, get back some code, test it while simultaneously asking the next question. It kept both me and the AI busy in parallel instead of me sitting around waiting.
Zero fees genuinely changed how I thought about the project. On Ethereum, I’d be obsessed with minimizing transactions to save on gas costs. On Qubic, I just kept adding features because why not? Want to add a pause button? Sure, that’s another transaction but it costs nothing. Want real-time updates every second? Go for it. The economic constraints just… disappeared.
Mistakes I Made
I waited until the last 2 hours to work on the demo video and presentation. And honestly, for some reason I never checked when the deadline was - I woke up after a coding tear through the night realizing I had two hours to slap together a presentation. I realized I should have been recording rough cuts throughout the build so I’d have options at the end instead of scrambling.
I also didn’t validate the idea with any potential users before building. I just assumed “micropayments = useful” and went for it. Probably should have asked a few creators or consumers if they’d actually want this before investing 48 hours.
The biggest blindspot was distribution. I built this thinking “the judges will see it and grade it” without considering “how do I get actual people to try it?” I only realized after submitting that getting people to notice your project is harder than building it.
What’s Interesting About This
Looking back, a few things stand out.
First, I genuinely couldn’t find anyone else doing per-second payments with a live counter like this. Maybe they exist and I just didn’t see them, but it feels novel? Which is weird because the idea itself is so obvious but like I said, I am new to the space and may just have overlooked it.
Second, zero fees aren’t just “nice to have.” They fundamentally change what’s economically viable. Micropayments go from theoretically interesting but practically impossible to just… trivial. That’s a bigger shift than I expected.
Third, the live counter is the killer feature. Everyone understands intellectually that blockchain can be “fast” and “cheap.” But watching three numbers update every single second makes it tangible in a way that technical specs never could.
Fourth, 48-hour deadlines force brutal clarity. You can’t overbuild. You can’t bikeshed about architecture. You ship the core thing or you ship nothing. Turns out that’s pretty freeing.
What Might Come Next
Disclaimer: these are ideas, not promises. I honestly don’t know if I’ll keep working on this or if anyone besides me thinks it’s interesting.
First, posting this blog post, and posting the app to places web3 pro devs hang out to get some actual feedback if this is a valid way to use Qubic and see how I could have built it better or different. That will at least give me a jumping off point for any future decisions I’ll make about where to go with this.
If I do keep going, the short-term stuff would be: deploying to Qubic’s actual network (right now it’s just running locally), making it work on phones, adding better error handling for when things go wrong.
The real first step is seeing if anyone besides me finds this concept interesting.
Try It Yourself
The whole thing is open source. You can clone the GitHub repo, install the dependencies (just Node.js), set it to demo mode, and watch the counter tick. Takes about 30 seconds to get it running.
I’m not linking it here because this isn’t meant to be a sales pitch. But if you’re curious, it’s on my GitHub under the same username.
Feel free to reach out if you’re interested.
The Bigger Picture
Micropayments have been “the next big thing” in payments for like 15 years. They just never worked because the fees always exceeded the payments themselves. It’s like trying to use a credit card to buy a piece of gum - the credit card processing fee costs more than the gum.
Qubic changes that equation. Not because it’s technically superior in every way or because it’ll replace Ethereum or whatever. But because zero fees make an entire class of transactions economically viable that just… weren’t before.
MicroStream is one small experiment in what that could look like. Maybe it goes nowhere. Maybe it’s a fun weekend project that taught me a lot. Maybe someone with more experience and resources builds on the idea and makes something actually useful.
Either way, I learned a ton and got to see those three numbers tick every second, which is honestly pretty cool.
Reflections
The hardest part of this whole thing wasn’t the code. It was time management.
While I understood what I built, being a newbie to the web3 and blockchain space made it hard for me to connect those dots and make it digestible in a presentation, which I only gave myself 2 hours to make. And it made figuring out where to start with research pretty difficult as well - while the the hackathon had advertised when it was going to happen and what it was going to be about, I didn’t start my research until the hackathon had actually started which in hindsight definitely was a big no-no.
I’m proud that it actually works - not a mockup, not a prototype, but something you can test right now. I’m proud that I shipped it on time with documentation and tests and a working demo. I’m proud of the live counter even though it’s just JavaScript’s setInterval function doing math every second.
If I could do it again, I’d start with the frontend to validate the concept first. I’d spend more time on the presentation throughout instead of scrambling at the end. I’d probably share progress while building instead of waiting until submission.
One More Thing
If you’re reading this and thinking “this could work for [some specific use case I haven’t thought of]” - genuinely, I’d love to hear about it. I’m still figuring out if this idea has legs beyond “neat weekend experiment.”
Or if you think it’s completely pointless, that’s also useful feedback. I’m learning in public here.
The code’s out there either way.
Tech Stack (For the Curious)
For anyone interested in the technical details: the smart contract is written in C++ using Qubic’s native contract system. It implements a payment channel pattern where funds get locked in the contract, time-based accrual happens on-chain, and settlement is instant. The backend is Node.js with Express handling the REST API, and there’s a demo mode that mocks all blockchain calls for faster testing. The frontend is vanilla JavaScript using setInterval to update the three counters every second, with the math being amountPaid = secondsWatched × ratePerSecond and remaining = deposit - amountPaid.
If you want to dig into the actual code, it’s all on GitHub. The payment channel logic is in PaymentChannel.cpp, the API is in server.js, and the counter is in viewer.js around line 227.
I also made a yt video for this if you would like to here me um and ah about it for 11 minutes.
Built for Qubic Hack the Future 2025 (Dec 5-7, 2025)
Tech: Qubic C++, Node.js, Vanilla JS, Make.com
Written with help from Claude Code during a caffeine-fueled weekend
Thanks for reading 🌊
What a neat article!