Dora NodaTechsy's July 19 "Heroku's Dead" comparison did the thing every Heroku refugee needed: it priced the same app on Railway, Render, and Fly.io at four tiers, re-checked every number against live pricing pages, and crowned a winner each time. The timing was no accident — Heroku had moved to a sustaining engineering model in February, and thousands of teams were shopping for a new home. Fly.io wins on raw cost at scale, Railway wins on pay-per-second simplicity, Render wins on predictable billing. But all three winners share one property — a meter that runs while your app runs. Add a fourth column for the same stack on owned Hetzner capacity, and the meter disappears entirely. Here is Techsy's table, recomputed.
The recomputed table, up front
Techsy's stacks and hosted numbers are theirs, re-checked July 19, 2026. The Hetzner column is ours, priced on post–June 15 Hetzner lists at roughly €1 = $1.17, with the whole stack — app, worker, Postgres, Redis — self-run on one box per tier.
| Tier | Stack | Railway | Render | Fly.io | Hetzner |
|---|---|---|---|---|---|
| Hobby | 1 web + 1 DB, under 100 req/day | ~$5/mo | $0 (free tier) | ~$4–6/mo | ~$5/mo (CX22-class shared) |
| Startup | 1 web + 1 worker + Postgres + Redis, ~500 req/min | ~$25–40/mo | ~$50–60/mo | ~$20–35/mo | ~$8/mo (CX33-class shared) |
| Growth | 2 web + 1 worker + Postgres + Redis, ~2K req/min | ~$80–120/mo | ~$130–175/mo | ~$60–90/mo | ~$15/mo (CX43-class shared) |
| Scale | 4 web + 2 workers + Postgres cluster + Redis, 10K+ req/min | ~$250–400/mo | ~$350–500/mo | ~$150–250/mo | ~$50/mo (AX41-class dedicated) |
Read it left to right and Techsy's verdicts hold: Fly.io is cheapest at Scale, Railway cheapest to reason about, Render cheapest to budget. Read it one column further and every hosted winner loses to the box by 3–7x — except at Hobby, where Render's $0 free tier beats everything, box included. That exception matters, and we'll come back to it, because "free beats five dollars" is the only tier where the meter losing isn't the self-hosted column.
How the Hetzner column is priced
Honest recompute means showing the box, not just the number. One box per tier, sized so the stack actually fits:
- Hobby (~$5): a CX22-class shared instance — 2 shared vCPUs, 4 GB RAM, 40 GB NVMe — lists around €4.59/month after Hetzner's June 15 cloud repricing. One web process plus a small Postgres fits comfortably.
- Startup (~$8): a CX33-class shared instance — 4 shared vCPUs, 8 GB RAM — around €7.19/month. Web, worker, Postgres, and Redis share 8 GB without strain at ~500 req/min.
- Growth (~$15): a CX43-class shared instance — 8 shared vCPUs, 16 GB RAM — around €12.49/month. Two web processes, a worker, and both datastores at ~2K req/min is well inside this envelope.
- Scale (~$50): an AX41-class dedicated box — 6 cores, 64 GB RAM — around €37–46/month. Four web processes, two workers, Postgres, and Redis on dedicated hardware with a 20 TB-class traffic allowance.
Two caveats, stated plainly. First, the Scale row assumes a single box; Techsy's hosted Scale stacks include a Postgres cluster, and matching that redundancy self-hosted means a second box, roughly doubling the column to ~$100 — still the cheapest Scale number in the table, but no longer by 5x. Second, Hetzner repriced cloud servers on June 15 (shared CX/CAX lines up ~1.3–1.4x, dedicated-vCPU CCX lines up 2.1–2.73x), so any comparison still quoting pre-June Hetzner numbers flatters the box by up to 3x. These are post-hike prices.
Tier by tier: where the meter disappears
Hobby: the box ties, free wins. Railway's ~$5 is its Hobby minimum, Fly.io's ~$4–6 is a small web Machine plus a small Postgres Machine with no free credit left to soften it, and the Hetzner box is ~$5. Three ways to pay five dollars — versus Render's $0 with 15-minute spin-down and 30–60-second cold starts. If your app serves under 100 requests a day and you can tolerate a slow first request, take the free tier. Self-hosting has no answer to zero; its pitch starts the moment you outgrow the free tier's limits.
Startup: the box wins by 3–7x. This is the tier where the meters diverge from the flat price. Railway's ~$25–40 is per-second metering ($0.00000772/vCPU-second, $0.00000386/GB-second) on an always-on stack — fair billing, but always-on means always-metered. Render's ~$50–60 is flat instances (Starter web at $7, Standard worker at $25, flexible Postgres from ~$6 plus $0.30/GB storage) that charge for reserved capacity whether traffic uses it or not. Fly.io's ~$20–35 is the cheapest hosted number and still 3–4x the ~$8 box. Nothing about a 500-req/min stack needs $35 of infrastructure; it needs $8 of box and someone willing to run Postgres on it.
Growth: the database floor decides the hosted ranking, and the box ignores it. At ~2K req/min the three hosted numbers spread to ~$80–120 / ~$130–175 / ~$60–90, and the spread is mostly the data layer: Railway's containerized Postgres meters compute per second with no production PITR option (its March 2026 HA Postgres is still labeled experimental — "don't run production data on it yet"), Render's managed Postgres with PITR and replicas is genuinely production-grade and priced like it, and Fly.io's cheapest path pairs cheap Machines with an external managed database because Fly Postgres is explicitly unmanaged. The ~$15 box absorbs all of this into one flat number — with the honest footnote that its Postgres is whatever backup discipline you bring.
Scale: egress joins the bill, and the box still doesn't move. At 10K+ req/min, Techsy's hosted Scale numbers ($250–400 / $350–500 / $150–250) start carrying meaningful bandwidth: Fly.io's $0.02/GB NA/EU egress is the reason it wins the hosted column, Railway's flat $0.05/GB roughly doubles that line, and Render's post-April metering at $0.15/GB past the included allowance can make bandwidth the single biggest line on the invoice. The ~$50 dedicated box includes a 20 TB-class allowance, so the line item that separates first from third among hosted vendors simply doesn't exist in the fourth column.
The two variables that move the ranking: egress and Postgres
A one-point table invites cherry-picking, so here is the sensitivity across the two variables that actually move the ranking.
Egress. Marginal cost per extra terabyte out of NA/EU: Fly.io +$18, Railway +$45, Render +$135 past its allowance, Hetzner +$0 inside 20 TB. Below 100 GB/month the difference is noise. Past roughly half a terabyte, egress dominates every metered invoice — at 1 TB, Render's bandwidth line alone ($135) costs more than the entire Scale box. If your app serves heavy API responses or static assets, the hosted decision is really an egress decision, and the box wins it by not having one.
Postgres. This is the variable the table understates, and it cuts the other way. Render's managed Postgres — PITR on all paid tiers, read replicas, automated backups, slow-query logs — is infrastructure you'd spend real engineering weeks replicating. Railway gives you a connection string on a single node with no PITR. Fly.io tells you outright its Postgres is unmanaged and most serious users pair it with Neon, Supabase, or PlanetScale. The Hetzner column's Postgres is self-run backups and self-owned 3 AM pages. Price the box at $50 and the managed-Postgres gap at "one engineer's on-call attention," and the honest total for a data-critical app is the box plus the ops burden — which is exactly why the DX section below, not the price table, is the real decision.
The DX a self-hosted PaaS has to match
Techsy's comparison is really two comparisons: the price table and the workflow table. The fourth column wins the first and says nothing about the second — so here is the minimum hosted-DX bar a self-hosted setup has to clear before the Hetzner column is a real choice rather than a theoretical one, mapped to Techsy's own verdicts.
Railway's 2-minute git-push (Techsy: best DX). Connect a repo, push, Railpack auto-detects the runtime, railway up from the terminal — no Dockerfile, no config file. The self-hosted equivalent is a buildpack-based deploy-from-git pipeline (buildpacks exist precisely so teams don't own Dockerfiles) plus preview environments per pull request. Railway auto-creates and auto-deletes PR environments; Render goes further with full infrastructure copies including databases. If your self-hosted flow can't preview a PR, you've given up the feature Techsy calls Render's killer one — and no price delta buys back a broken review workflow.
Render's managed Postgres and flat teams (Techsy: best for production SaaS and teams). PITR, replicas, automated backups — plus, since the April 23 replan, a flat $25 Pro workspace with unlimited seats instead of $19/member. A self-hosted platform answers with automated Postgres backups and point-in-time restore as a built-in, not a runbook — and its team story is trivially flat, because there are no seats on your own box at all. A five-person team pays $25 on Render versus $0 of seat fees self-hosted; the seats were never the self-hosted problem, the managed data layer is.
Fly.io's scale-to-zero and Docker control (Techsy: best for global and idle workloads). Machines that stop with no traffic and wake in 300ms–2s, 18 regions, fly.toml control over release commands and deployment strategy. This is the one DX dimension a single Hetzner box genuinely cannot match: one box is one region, and scale-to-zero on owned hardware saves nothing because the box bills flat anyway. If your users span continents or your workloads idle 20 hours a day, Fly.io's hosted column — not the box — is the honest answer. The box wins always-on, single-region workloads; it has no story for the workloads Fly.io was built for.
Verdict: add the column, then match the workflow
Techsy's graduation path — start on Railway, move to Render for production Postgres, move to Fly.io for global latency — is sound advice inside the hosted world. The fourth column adds the exit ramp: at Startup tier and above, every hosted winner costs 3–7x the box, the meter that separates them (per-second compute, per-GB egress, the $38 managed-Postgres floor) vanishes on owned capacity, and the only hosted numbers the box can't beat are $0 free tiers and genuinely global workloads.
But the recompute only sticks if the self-hosted side matches the workflow, not just the price. Git-push deploys with buildpacks, PR previews with database copies, automated Postgres backups with point-in-time restore — that is the DX checklist the Hetzner column owes Techsy's table. Match it, and the fourth column isn't a thought experiment; it's your invoice.
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.
