Cloud Bill? What Cloud Bill? The Builders Running Real Apps for Free

The cloud was supposed to democratize infrastructure. And in a lot of ways, it did. You no longer needed to rack servers or negotiate datacenter contracts to launch something real. You could spin up a VM, deploy an app, and be live in twenty minutes.

But somewhere along the way, the democratization story got complicated. Monthly bills crept up. Free tiers expired. Egress fees appeared on invoices like uninvited houseguests. A side project that cost $8 a month in 2019 somehow costs $140 now, and half of that is for services you're not entirely sure you're using.

A contingent of developers has decided they're done with that math. They're building and shipping real, production-grade applications — some of them profitable — on infrastructure that costs them nothing. Or close enough to nothing that the difference doesn't matter.

Here's how they're doing it, and what they've had to give up to get there.

The Free Tier Landscape Has Actually Gotten Pretty Good

The first thing worth understanding is that the zero-cost infrastructure stack isn't a hack or a loophole. It's a deliberate combination of legitimate, permanent free tiers from platforms that have financial incentives to keep developers hooked.

Cloudflare Workers gives you 100,000 requests per day on the free plan with no cold starts and global edge distribution. That's not a trial — that's the product. Cloudflare's business model depends on developers building on their platform and eventually upgrading, which means their free tier is genuinely generous and relatively stable.

Vercel and Netlify both offer free hosting for front-end projects with serverless function support. GitHub Pages handles static sites with no usage limits. PlanetScale's free tier (when it existed) spoiled a lot of developers, and while that particular door has closed, Turso — a distributed SQLite platform — offers 500 databases and 9GB of storage on its free plan. Neon Postgres gives you a serverless Postgres instance that scales to zero when idle.

Stack these together thoughtfully and you have a legitimate application platform that costs nothing at moderate traffic levels.

Real Projects, Real Zero Bills

This isn't theoretical. There are developers shipping actual products on this kind of setup.

One indie developer running a B2B SaaS tool for small legal practices has been operating on a stack of Cloudflare Workers, Turso, and Cloudflare R2 for object storage for over a year. The app processes thousands of requests daily, stores client documents, and generates consistent monthly revenue. The infrastructure bill is zero. "I pay for my domain and that's it," he said in a community thread. "I've been waiting for something to break or a bill to appear and neither has happened."

Another developer — building a content aggregation tool that pulls RSS feeds, processes them, and serves a cleaned-up reading interface — runs the entire thing on a combination of GitHub Actions (for scheduled jobs), GitHub Pages (for the front end), and a free Neon Postgres instance. The processing happens in Actions workflows on a cron schedule. The compute is free. The storage is free. The hosting is free.

These aren't toy projects. They're products with users, some with paying customers, running on infrastructure that costs nothing.

The Old Hardware Angle

Not every zero-bill stack lives in the cloud. Some of the most interesting setups involve hardware that's already paid for.

A small but vocal community of developers runs production workloads on old hardware — a decommissioned Mac Mini, a ThinkPad sitting under a desk, a Raspberry Pi 4 in a closet. Pair that with Cloudflare Tunnel (free tier, no open ports required) and you have a publicly accessible server that costs nothing beyond electricity and the initial hardware purchase.

This approach has real limitations — you're on the hook for uptime, hardware failure, and home internet reliability — but for certain workloads, especially internal tools, personal projects, or low-stakes public apps, it works. And the people doing it tend to be very clear-eyed about the trade-offs.

"I know my uptime isn't 99.9%," said one developer who runs a personal finance tracker and a small link-sharing app from a machine in his home office. "It goes down when my internet does. I'm fine with that. I'm not running a hospital."

What You Actually Give Up

Let's be honest about the trade-offs, because there are real ones.

Vendor risk is real. Free tiers change. PlanetScale's free plan disappearing was a genuine disruption for developers who'd built on it. Any stack built on free tiers is betting that those tiers stay generous. That's not a sure thing.

Operational ceiling is lower. If your app goes viral or you land a big customer and traffic spikes, a free-tier stack may not handle it gracefully. Cloudflare Workers will handle burst traffic fine, but a free Postgres instance has connection and storage limits that you'll hit eventually.

Debugging gets harder. Distributed free-tier infrastructure across multiple platforms means your observability story is fragmented. You're pulling logs from multiple dashboards, and the free tiers of those dashboards often have limited retention and query capabilities.

Support is on you. There's no SLA on a free plan. When something breaks, you're debugging it yourself with documentation and community forums. For a solo builder, that's usually fine. For a team shipping something business-critical, it's a genuine risk.

When This Makes Sense

The zero-cost stack isn't for everyone or every project. But it makes a lot of sense for a specific profile: solo developers or small teams building products that need to validate before they scale, side projects with uncertain futures, internal tools where downtime tolerance is high, and early-stage startups trying to extend runway as far as possible.

The calculus changes when you have enterprise customers with SLA requirements, when compliance demands specific certifications, or when your team doesn't have the bandwidth to manage the operational complexity of a stitched-together free-tier stack.

But for the developers it fits, the benefits aren't just financial. There's something genuinely clarifying about building with constraints. When you can't throw money at infrastructure problems, you write leaner code, design simpler systems, and think harder about what your application actually needs to do.

The Bigger Point

The zero-bill stack is less a statement about cloud vendors and more a statement about intentionality. The developers doing this aren't anti-cloud ideologues — most of them have day jobs where they use AWS or GCP all day. They've just decided that for their own projects, the default of "spin up a cloud instance and figure out the bill later" doesn't serve them.

They're shipping. They're profitable, or getting there. And they're doing it without a line item that compounds every month whether or not they look at it.

That's worth paying attention to.