Dora NodaFlavio Copes checked every major hosting free tier against the providers' own pricing pages on September 16, 2026, and the bottom line fits in one sentence: nobody gives you an always-awake app for free anymore. The floor for a process that never sleeps is Fly at about $2 a month, Vultr at $3.50, DigitalOcean at $4, and Railway Hobby at $5 — and the cheapest managed Postgres is another $5–6 on top. If you are parking a handful of hobby apps and side projects on entry-level meters, per-app billing quietly re-adds the exact bill free tiers used to erase. This post works the comparison: three small apps plus a database on every entry meter, versus consolidating all of it on one flat-rate ~€5 Hetzner box behind a git-push PaaS.
Here is the verdict before the why: at one always-on app, pay the cheapest meter and skip the ops. At three or more, one flat-rate box wins on price by 2–5×, and the only honest question left is what your ops time is worth. The table below is the whole argument; the rest of this post shows the receipts.
The always-awake floor, September 2026
| Provider | Cheapest always-awake unit | Sleep behavior | Card required? |
|---|---|---|---|
| Fly.io | ~$2/mo (shared-cpu-1x, 256 MB) | None — runs until you stop it | Yes, after the 7-day trial |
| Vultr | $3.50/mo (512 MB with IPv4) | None — it's a VPS | Yes, from the first hour |
| DigitalOcean | $4/mo Droplet (1 vCPU, 512 MB) | None — it's a VPS | Yes, from the first hour |
| Railway Hobby | $5/mo (includes $5 of usage) | None while credit covers usage | Yes, for Hobby |
| Heroku Eco | $5/mo (1,000 dyno-hour pool)* | *Sleeps after 30 idle min | Yes — paid plan |
| Heroku Basic | $7/mo per dyno | None — truly always-on | Yes — paid plan |
| Render Starter | $7/mo per service | None — free tier is the one that sleeps | No for free; yes for paid |
| Hetzner CX22 | ~€5/mo all-in (2 vCPU, 4 GB, 40 GB, 20 TB) | None — it's a VPS | Yes, from the first hour |
Two footnotes matter before you read further. First, the Heroku asterisk: Eco dynos sleep after 30 minutes of inactivity and share a single 1,000-dyno-hour monthly pool, so three always-on Eco dynos (2,160 dyno-hours) don't even fit in one account's pool — true always-awake on Heroku starts at Basic, $7 per dyno. Second, Fly's $1.94 becomes $2.19 on October 1, 2026, when Fly raises RAM from $5 to $6 per GB-month. The $2 floor is already scheduled to move.
And the database line, which every "hosting for $2" pitch hopes you forget: the cheapest managed Postgres anywhere on this list is $5 for 1 GB at Heroku or $6 at Render. Compute got cheap; managed state did not.
What "$0" actually buys in September 2026
The free column isn't empty — it's conditional. Every $0 tier is some combination of a sleep timer, a trial clock, and a card on file:
- Render (free): 512 MB web service from a 750-hour monthly pool, spins down after 15 idle minutes, takes about a minute to wake behind a loading page. Free Postgres is 1 GB and expires 30 days after creation. Render's own docs say not to use free services for production.
- Railway (Free): $1 of usage credit a month, no rollover. At $10 per GB of RAM per month, $1 keeps about 100 MB of RAM alive for a month — a cron job and little else. The one-time $5 trial credit lasts roughly 30 days first.
- Fly.io: no monthly allowance at all — a trial of 2 total machine-hours or 7 days, whichever hits first, with trial machines stopping after 5 minutes of runtime. Then every organization needs a card on file.
- Heroku: nothing free since November 28, 2022. Eco is the cheapest paid rung and it sleeps.
- Vercel Hobby / Netlify Free: still genuinely $0 for static and light serverless, but Hobby is personal non-commercial use only, and Netlify's 300 monthly credits price a production deploy at 15 credits each — a blog publishing daily runs out on deploys alone.
- Cloudflare Workers/Pages and Google Cloud Run: the two most generous $0 compute stories left — Cloudflare with unlimited static plus 100k Worker requests a day and no card, Cloud Run with a real always-free container allowance inside Google's billing system (where an alerts-only budget emails you but doesn't stop spending).
The pattern is unmistakable: "free tier" in 2026 means a sleep timer plus a credit card on file. The moment a project needs to stay up or keep data past 30 days, $4–7 a month per unit is the honest price. Copes puts it bluntly: he'd rather pay it than fight a free plan's limits. The question is how many times you pay it.
The worked comparison: three apps and a database
Take the typical hobby portfolio: three small always-on apps (a side-project API, a self-hosted tool, an experiment you're showing people) plus one Postgres database. Here is the monthly total on each meter, compute plus the cheapest managed Postgres:
| Stack | 3× app compute | + managed Postgres | Monthly total |
|---|---|---|---|
| Fly.io | 3 × $1.94 ≈ $5.82 | +$5 (cheapest managed PG) | ~$11 |
| Vultr | 3 × $3.50 = $10.50 | +$5 | ~$16 |
| DigitalOcean | 3 × $4 = $12 | +$5 | ~$17 |
| Railway Hobby | ~$17 usage* | +$5 | ~$22 |
| Heroku (always-awake) | 3 × $7 Basic = $21 | +$5 | ~$26 |
| Render | 3 × $7 = $21 | +$6 | ~$27 |
| Hetzner CX22 + git-push PaaS | all 3 apps + self-managed PG | included |
*Railway math, shown so you can check it: three 512 MB services ≈ 1.5 GB RAM × $10/GB-month ≈ $15, plus ~$2 of vCPU time at $20/vCPU-month ≈ $17 of usage against the $5 included credit — so $5 base + ~$12 overage. Lightweight apps meter less; anything holding memory meters more. That's the point of usage billing: the entry price is legible, the steady-state price is a function of your RSS graph.
The Hetzner row needs no asterisk on price: one CX22 (2 shared vCPUs, 4 GB RAM, 40 GB NVMe, 20 TB of transfer, roughly €3.79–4.51 plus an IPv4 fee depending on billing) runs all three apps, a self-managed Postgres, and the git-push PaaS layer itself for one flat ~€5. That's half the cheapest metered stack and a fifth of the priciest — for the same three apps and one database.
Now the sensitivity check, because the honest answer depends on app count:
| Portfolio | Cheapest meter (Fly + PG) | Priciest meter (Render + PG) | Hetzner CX22 |
|---|---|---|---|
| 1 app + PG | ~$7 | ~$13 | ~€5 |
| 3 apps + PG | ~$11 | ~$27 | ~€5 |
| 5 apps + PG | ~$15 | ~$41 | ~€5 (until 4 GB RAM fills) |
Per-app meters scale linearly with every project you start; the flat box doesn't move until you exhaust its RAM. The crossover is brutal: the €5 box wins on price at essentially any app count, and the gap widens with every side project. What the box can't do is sleep, scale to zero, or hand you a managed database with backups you never think about — which is exactly where the next two sections come in.
What the €5 box actually is
A Hetzner CX22 is 2 shared vCPUs, 4 GB of RAM, 40 GB of NVMe, and 20 TB of monthly transfer for roughly €4–5 including an IPv4 address. Four gigabytes is the key number: it's enough for a git-push PaaS layer (Coolify or Dokku, both open-source — budget ~1 GB of resident overhead for the heavier panels), three small app containers, and a Postgres with room to breathe. Builders consistently report 4 GB as the floor below which a compose stack plus database starts OOMing; the CX22 sits exactly on that floor, which is why it's the box and not the cheaper 2 GB tier.
The price gap isn't magic — it's a transfer of labor. The ~$6–22 a month you save over metered stacks is paid in ops you now own:
- Postgres is yours: installation, minor-version upgrades, backup cron plus off-box copies, and the 2 a.m. restore you practice once so it isn't a surprise. Managed $5–6 Postgres exists precisely to sell this away.
- TLS and deploys are yours: Caddy or Traefik terminates HTTPS for free, and the git-push layer rebuilds on push — but you set both up, and you debug the failed build at midnight instead of opening a ticket.
- One box is one failure domain: no autoscaling, no multi-zone failover, no managed load balancer. For hobby apps that's usually fine; for anything with users who page you, it's the real cost.
- Setup is an afternoon, maintenance is a habit: unattended security upgrades plus a monthly glance at disk usage covers most of it, but "most of it" is doing real work in that sentence.
None of this is an argument against the box — it's the actual price tag. The metered platforms charge you $6–22 a month to not think about Postgres backups. Whether that's a bargain or a tax depends on how you value a Saturday afternoon, which brings us to the decision rule.
When the meter wins anyway
The box wins on price nearly everywhere, so the interesting question is when to pay the meter regardless:
- One app and zero ops appetite. A single always-on side project on Fly (~$7 with Postgres) or Railway Hobby ($5 while it fits the credit) costs less than one hour of your time is worth. Don't build a platform for one app.
- Static or bursty serverless workloads. This whole comparison is about processes that must stay awake. If your app can sleep, Cloudflare Pages, Vercel Hobby (personal use), Netlify, Deno Deploy, or Cloud Run's always-free tier are still genuinely $0 — don't rent a VPS for a cron-shaped problem.
- Spool-up speed over steady-state cost. Trial credits (Railway's $5, Fly's trial week, Render's 30-day Postgres) are for evaluating stacks, not for living on. Use them, then consolidate.
- Anything with uptime promises. The day someone else depends on your app, the managed database and the second availability zone stop being luxuries. Hobby math ends where other people's pager begins.
For everything else — the portfolio of three to five always-on experiments that used to live on Heroku's free dynos — consolidation is the new free tier. The free plans didn't disappear so much as move: from $0 with a sleep timer to ~€5 flat with root access.
FlavioCopes' audit marks the end of an era that started dying in November 2022, when Heroku killed free dynos: the era where a hobbyist could scatter a dozen always-on projects across free tiers and pay nothing. In September 2026 the honest menu is a sleep timer, a trial clock, or $2–7 per app per month — and the longer your project list grows, the more those per-app meters look like the bill the free tier used to erase. The developers who noticed early already did the math: static things on Cloudflare's free plan, and everything that must stay awake consolidated on one flat-rate box they own.
Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own. Star the repo on GitHub or deploy your first app today.
