Dora NodaHeroku spent 2026 winding down. After the February announcement that the platform was shifting to sustaining engineering — no new features, no new enterprise contracts — thousands of teams started pricing their exit. In July, Techsy's Mert Batur did the homework for them: a Railway vs Render vs Fly.io comparison, every price re-checked against live pages on July 19, 2026, with the same app costed on all three platforms across four tiers.
It is a good comparison, and it is missing a column. Railway, Render, and Fly.io all bill you for the service — per GB of RAM, per flat-rate tier, per metered component. None of them is the cheapest way to run the stack they describe. So here is the fourth column: the same four workloads on flat-rate Hetzner machines, priced from public list prices, with the exact spec each tier assumes. The headline result is that the PaaS bills win at Hobby and lose everywhere else — by roughly 3x against the cheapest PaaS at Scale, and more against Render's flat tiers.
The table Techsy didn't print
First, the workload spec, so "same app" means something checkable. Each tier below names approximate compute, memory, and egress:
- Hobby — 1 web service (~0.5 vCPU / 512 MB) + single-node Postgres + under 10 GB egress/month. Fewer than 100 requests a day.
- Startup — 1 web + 1 worker (~2 vCPU / 4 GB total) + Postgres + Redis + ~100 GB egress/month. Around 500 requests/minute.
- Growth — 2 web + 1 worker (~4–6 vCPU / 8–12 GB) + Postgres + Redis + ~500 GB–1 TB egress/month. Around 2,000 requests/minute.
- Scale — 4 web + 2 workers (~10+ vCPU / 32 GB) + Postgres cluster + Redis + multi-TB egress/month. Over 10,000 requests/minute.
And the Hetzner mapping, one flat-rate machine (or two) per tier: Hobby runs on an entry shared-vCPU cloud server (CX23-class, 2 vCPU / 4 GB, about €5.49/month plus a small IPv4 fee). Startup fits on a 4 vCPU / 8 GB dedicated-vCPU box (€14–16/month). Growth takes an 8 vCPU / 16 GB box (€28–32/month), doubled if you want the database on its own machine. Scale gets a single-tenant dedicated AX/EX-class server (~€44–50/month) plus volumes and backups. Every one of these is a flat monthly machine rate — no per-GB-RAM meter, no per-service fee — with 20 TB of outbound traffic included per server and overage around €1/TB.
Purists can skip the cloud VMs entirely: Hetzner's Server Auction and EX-line dedicated boxes start in the low tens of euros a month, and a single auction box absorbs the Hobby, Startup, and Growth tiers outright.
| Tier | Stack | Railway | Render | Fly.io | Hetzner box |
|---|---|---|---|---|---|
| Hobby | 1 web + 1 DB, <100 req/day | ~$5/mo | $0 (free tier) | ~$4–6/mo | ~$7/mo |
| Startup | 1 web + 1 worker + PG + Redis, ~500 req/min | ~$25–40/mo | ~$50–60/mo | ~$20–35/mo | ~$17/mo |
| Growth | 2 web + 1 worker + PG + Redis, ~2K req/min | ~$80–120/mo | ~$130–175/mo | ~$60–90/mo | ~$35–65/mo |
| Scale | 4 web + 2 workers + PG cluster + Redis, 10K+ req/min | ~$250–400/mo | ~$350–500/mo | ~$150–250/mo | ~$55–95/mo |
| Delta vs cheapest PaaS | Hobby: +$2 · Startup: −$5–20 · Growth: −$25–55 · Scale: −$95–155 |
Read the delta row carefully, because it refuses to flatter the premise: at Hobby, the Hetzner box loses. Render's free tier is $0, and Railway and Fly.io both come in under $7. The flat-rate box only starts paying at Startup, breaks clearly ahead at Growth, and is a different sport entirely at Scale, where the cheapest PaaS bill (Fly.io, ~$150–250) runs roughly triple the dedicated box. That crossover — lose small, then win big — is the whole story. Now let's price each side of it honestly.
How the Hetzner column is priced
The PaaS numbers above are Techsy's, and they match the platforms' own docs. Railway's pricing page confirms the $5 Hobby / $20 Pro subscriptions (which count toward usage) and the metered rates: $10/GB of RAM, $20/vCPU, $0.05/GB egress, and $0.15/GB/month for volumes. Fly.io's pricing docs confirm the baseline VM (1 shared CPU / 256 MB at $2.02/month running 24/7, plus ~$5/GB for extra RAM), $0.15/GB/month volumes, $2/month dedicated IPv4, and self-managed Postgres from ~$2/month for a single dev node to $82–164/month for a three-node production cluster.
Render's flat tiers — $7 Starter, $25 Standard, $85–450 Pro — plus Postgres compute from ~$6 with storage metered at $0.30/GB, are as Techsy re-checked them in July.
The Hetzner side is built the same way, from hetzner.com/cloud list prices with two adjustments worth stating. First, Hetzner raised cloud prices during 2026, so the ranges above carry slack on purpose — the entry 2 vCPU / 4 GB server that used to list near €4.50 now lists near €5.49, and dollar equivalents assume roughly €1 ≈ $1.10–1.15. If you re-run this table in six months, re-check the live page the way Techsy did. Second, the Hetzner cells include the boring add-ons the PaaS cells bundle invisibly: an IPv4 address (~€0.50/month on cloud VMs), a volume for Postgres data (single-digit euros), and backup/snapshot space at the Scale tier.
What makes the comparison structurally lopsided is traffic. Every Hetzner cloud server includes 20 TB of outbound traffic per month — pooled across a project, so one quiet server's allowance covers a loud one's overage — with extra traffic around €1/TB in EU and US locations. None of the four tiers comes close to that allowance, which means egress is a $0 line on the Hetzner side at every tier. Hold that thought: on the PaaS side, egress is where the bills go to grow teeth.
Where each bill hides its tax
Each platform has one billing shape, and each shape hides a different cost. Here is the line item to watch on each bill, with the traffic level that makes it bite.
Railway's tax is memory plus egress. At $10/GB of RAM per month, a 4 GB workload pays $40 for memory alone before compute, and at $0.05/GB, egress costs $50/TB — fifty times Hetzner's overage rate. For a chatty API pushing 2 TB/month, that is +$100 on top of compute, enough to double a Growth-tier bill. Below ~100 GB/month of egress, the tax is invisible and Railway's pay-per-second model is genuinely the cheapest way to run small; above ~1 TB, egress quietly becomes the largest line item. This is the sensitivity that matters: Railway wins the low-traffic game and taxes the high-traffic one.
Render's tax is idle capacity. Flat-rate tiers are reservation-shaped: a $25 Standard instance costs $25 whether it serves 500 requests a minute or five. At 20% average utilization you are paying roughly 5x per request versus a metered platform — the predictability Techsy praises is real, but its price is the gap between reserved and used. Two more lines compound it: Postgres storage at $0.30/GB/month sits on top of the flat compute fee rather than inside it, and the free tier's 15-minute spin-down with 30–60-second cold starts means the $0 Hobby cell comes with a user-facing latency cliff. Paid plans ($7+/month) stay warm with a minimum of one instance — Render does not scale to zero on paid tiers — so the cliff becomes a floor: you pay for one warm instance forever.
Fly.io's tax is the meter count. Per-second Machines billing is fair, but the invoice has five meters — Machines, extra RAM, volumes, IPs, and three egress tiers ($0.02/GB in North America and Europe, $0.04 in Asia-Pacific and South America, $0.12 in Africa and India). The classic complaint that Fly.io pricing "requires a spreadsheet" is really about interaction effects: an APAC-heavy workload pays double the egress of a NA/EU one, an always-on fleet pays for machines that scale-to-zero would have stopped, and a production Postgres setup means either $82–164/month of self-managed Machines and volumes or a separate external database bill (Neon, Supabase) that never appears in Fly.io's own table. Fly.io is still the cheapest PaaS at Scale in NA/EU — $0.02/GB egress undercuts Railway by 60% — but only if you actively manage the meters.
One sensitivity case ties all three together: take the Growth tier at 2 TB/month egress instead of the assumed ~750 GB. Railway adds ~$100, Fly.io adds $40 in NA/EU ($80 in APAC), Render adds $0 (egress included) but keeps charging for reserved headroom, and Hetzner adds $0 with 18 TB of allowance still untouched. Traffic is the variable that flips winners — which is exactly why a comparison that assumes one traffic level per tier has to name it, as the spec box above does.
What the Hetzner number doesn't buy
A cost table that stopped here would be marketing, not analysis. The Hetzner column buys raw machines; the PaaS columns buy machines plus operations. Here is the counter-table — what each PaaS bill includes that the Hetzner number does not — mapped to the tier where it actually matters.
| What you give up | Who bundles it | Tier where it bites |
|---|---|---|
| Managed Postgres with point-in-time recovery | Render (PITR on all paid tiers, replicas upmarket) | Growth and up — a corrupt database without PITR is a company-ending event |
| Zero-ops deploys, patching, incident response | All three (to varying degrees) | Every tier — budget real hours or real salary for the Hetzner side |
| PR preview environments | Railway (auto-created, auto-deleted), Render (full infra copies with DB) | Startup and up — the faster you ship, the more previews are worth |
| Global latency (18 regions, multi-region deploys) | Fly.io | Scale — single-region Hetzner adds 100–200 ms for far-away users |
| Scale-to-zero for idle services | Fly.io (300 ms–2 s cold starts) | Hobby — ironically the tier where Hetzner already loses on price |
| Team RBAC, SSO, audit logs | Render ($25/mo flat Pro workspace since April 2026), Railway Pro | Growth and up — compliance arrives with headcount |
Two rows deserve emphasis because they are where teams most often misprice the move. First, Postgres: Railway's default is still a single containerized node with no PITR, and its March 2026 one-click HA upgrade (Patroni, etcd, HAProxy) is explicitly labeled experimental — Railway's own changelog says not to run production data on it yet. Fly.io is blunter still: Fly Postgres is community-maintained and unmanaged ("if Postgres crashes… you'll need to do a little work to get it back"). Only Render's Postgres is genuinely managed. That means the Hetzner column's honest database comparison is either DIY Postgres with your own Barman/pgBackRest backups or a managed-external bill (Neon, Supabase) added on top — either way, not $0 in money or hours.
Second, ops time: the Hetzner column assumes somebody patches the OS, rotates the backups, renews the certs, and answers the 3 AM page. For a solo developer that somebody is you, and the "savings" at Startup (~$5–20/month) price your on-call time at pennies an hour. The math inverts with scale — at Growth and Scale the savings (tens of dollars at Growth, over a hundred at Scale) start buying back real hours — but there is no tier where the machine bill is the whole bill. Anyone presenting the fourth column without this counter-table is selling, not comparing.
The graduation path, extended
Techsy ends with a graduation path — start on Railway while iterating, move to Render when production Postgres and previews matter, choose Fly.io when latency goes global — and it is good advice. This post extends it by one stage: move to flat-rate machines when the meter becomes the bill. The trigger is concrete. When your Railway invoice's egress line passes your compute line, when your Render fleet's average utilization drops under a third, when your Fly.io spreadsheet needs its own spreadsheet — that is the meter telling you it has outlived its convenience. For most teams that moment lands somewhere in the Growth tier, around the second $100+ invoice that made somebody open the billing page and frown.
Who should stay put? Solo developers and pre-launch prototypes should stay on Railway or Render's free tier — at Hobby scale the PaaS is cheaper and operated, which is the rarest combination in infrastructure. Teams with users on three continents and no appetite for anycast should stay on Fly.io; Hetzner's EU/US/Singapore footprint cannot fake 18 regions. Teams handling regulated data with a two-person engineering staff should stay on Render, where PITR and audit logs arrive without hiring a DBA. The fourth column is for teams whose workload is boring in the best way — steady traffic, one or two regions, a database they already understand — because boring is what flat-rate iron prices best.
That is also, not coincidentally, the shape of workload a self-hosted PaaS exists to serve. The three bills are the price of renting someone else's operations; the fourth column is the price of the machines underneath. The industry spent the Heroku decade learning that the operations are worth paying for — and the post-Heroku decade will be about learning exactly when they stop being worth that much.
Running the numbers on your own exit? Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own, with a Render-compatible API your existing configs already speak. Star the repo or deploy your first app today.
