Railway vs Render vs Fly.io vs a €4 Hetzner Box: A Line-by-Line Bill for the Same Node.js + Postgres App

CheckThat.ai's July 2026 pricing census put Railway, Render, and Fly.io on one comparison table for the first time — Railway's per-second metering at roughly $10/GB of RAM and $20/vCPU per month, Render's flat $7 compute, Fly.io's $2 shared machine. The table invites the obvious question and then refuses to answer it: what does the same app actually cost on each? So I recomputed the bill line by line for one boring, typical workload, and added the fourth option the census leaves out — a flat-rate Hetzner box you own.

Here is the answer up front. For a Node.js app plus Postgres, running 24/7 with 10GB of monthly egress:

Three different metering shapes — per-second usage, flat per service, per-second with geographic egress — and the owned box still invoices less than half of the cheapest of them. The rest of this post shows every line of arithmetic, states every assumption so you can check my math, and then stress-tests the verdict: where each shape wins, where each breaks, and what "just buy the box" honestly costs in labor.

The workload we're pricing (so you can check my math)​

Every number below prices this exact footprint:

• App: Node.js service, 0.5 vCPU / 512MB RAM, running 24/7
• Database: Postgres, single node, modestly sized
• Storage: 5GB persistent volume
• Egress: 10GB/month outbound to the public internet
• Region: North America or Europe
• Prices: current public list prices as of September 2026, before VAT/sales tax

This is deliberately unremarkable — a side project that grew up, an internal tool, a small SaaS at the start. It matches the shape of CheckThat.ai's own worked example (Node.js + Postgres with 5GB of volume storage and 10GB of egress on Railway's Pro tier at $26.60), which gives us an independent check on the Railway arithmetic later.

Railway: the meter runs per second​

Railway bills actual consumption per second against plan credit. The unit rates, confirmed by both Railway's docs and the CheckThat census:

• RAM: ~$10/GB/month ($0.00000386 per GB-second)
• vCPU: ~$20/vCPU/month ($0.00000772 per vCPU-second)
• Volumes: ~$0.15/GB/month
• Egress: $0.05/GB
• Plans: $5/month Hobby (with $5 of included credit) or $20/month Pro (with $20 of included credit), after a one-time $5 trial credit

Now the lines for our workload:

On Hobby you pay the $5 subscription plus ~$21.25 of usage beyond the $5 credit; on Pro you pay $20 plus ~$6.25 beyond the $20 credit. Either way the invoice lands at ≈ $26 — within rounding of CheckThat.ai's independently computed $26.60 for the equivalent stack. When a workload never sleeps, the plan floor barely matters; the meter is the bill.

Context worth knowing: Railway raised $100M in 2026 to build what it calls AI-native cloud on its own data-center footprint, after migrating off Google Cloud in 2024. Per-second billing for real consumption is genuinely cheaper than the hyperscalers for bursty shapes — but "bursty" is doing all the work in that sentence, as we'll see.

Render: flat per service, metered at the edges​

Render's shape is the simplest to forecast: a flat monthly price per service, prorated by the second, with metered bandwidth only once you exceed the generous included pool.

The Starter tier maps exactly onto our app spec, which is no coincidence — this is the workload Render's entry tier is designed around. The Postgres line deserves a note: Basic 256MB is the smallest managed Postgres and its 256MB of RAM is leaner than the self-managed Postgres we're pricing elsewhere, so Render's $13 is doing slightly less work on the database side. Step up to Basic 1GB (~$19) and Render passes Railway's total — the flat-per-service model stays cheap exactly as long as every service fits the bottom rung.

Fly.io: cheapest lines, spikiest geography​

Fly.io meters Machines per second while started, with list prices that look almost free until you assemble the whole stack:

Two things to notice. First, Fly's volume billing is on provisioned capacity, charged even when the machine is stopped — right-size volumes or pay for air. Second, the egress line is where Fly's geography tax hides: $0.02/GB in North America and Europe, $0.04 in Asia-Pacific and South America, and $0.12/GB in Africa and India. At 10GB that spread is $0.20 versus $1.20 — noise. At 100GB it's $2 versus $12, more than the compute itself. Region choice moves Fly's total more than any machine sizing decision, which the flat "$2" headline never hints at.

Hetzner CX22: one line, €4-ish​

The Hetzner Cloud CX22 — 2 shared vCPUs, 4GB RAM, 40GB SSD, 20TB of included traffic — lists at roughly €4–4.50/month before VAT, about $5. Our entire workload (1GB RAM, under 1 vCPU, 5GB disk, 10GB egress) fits on it with most of the box still idle. There is no second line. No RAM meter, no egress meter within the 20TB pool, no per-service fee, no plan floor.

Three honest caveats, because the flat number invites lazy reading. First, that price excludes VAT — German VAT brings it to roughly €5. Second, the 20TB traffic pool applies to EU locations; confirm the included quota if you deploy in Hetzner's US regions. Third and largest: the $5 buys raw capacity, not operations. Postgres backups, OS patching, TLS renewal, and the 3 a.m. page are yours now. We'll price that labor in a moment — but note the shape of the answer first: every PaaS line item above (RAM-seconds, provisioned volumes, regional egress) collapses into one flat number the moment the machine is owned.

Sensitivity: where each shape wins and breaks​

A single workload proves nothing if the verdict flips the moment traffic moves. So here is the same table recomputed at three other points:

Read the rows, not just the columns:

• Egress-heavy: Railway's $0.05/GB adds $4.50 per extra 90GB; Fly's NA/EU rate adds only $1.80 — but Fly's India rate adds $10.80, more than doubling its bill. Render's 100GB included pool absorbs the whole row. Hetzner doesn't notice; 100GB is 0.5% of its pool.
• Geography: only Fly's bill depends on where the bytes land. If your users are in Mumbai or Lagos, Fly's cheapest-line story inverts — verify the region-group table before trusting any Fly estimate computed with $0.02.
• Bursty/idle: this is the one row where metering earns its keep. A workload running 30% of the time drops Railway to roughly the $5 floor plus ~$5 of usage, and Fly's auto-stop machines fall to a few dollars of stopped-rootfs and volume charges. Render's flat $13 doesn't move — flat pricing is a subscription to capacity whether you use it or not. Hetzner doesn't move either, and at ~$5 it doesn't need to: it was already the floor.
• Multi-region: doubling Fly's machines roughly doubles Fly's compute; Railway and Render multiply per service per region; Hetzner means a second €4 box. Nobody escapes multiplication — the owned box just multiplies the smallest number.

The pattern across all four rows: metering shapes determine who pays for idleness and distance, and the flat box wins every steady-state row because it charges for neither.

The honest counter: ops labor is a line item too​

Everything above prices infrastructure, and infrastructure isn't the whole bill. Railway, Render, and Fly.io all bundle managed Postgres with backups, automated TLS, zero-downtime deploys, log retention, and someone else's pager. On the Hetzner box, each of those is a thing you build or a 3 a.m. lesson you schedule for yourself.

So who should stay on the meter? If you have no one who can resuscitate Postgres, stay on managed — a single data-loss incident costs more than years of the $8–21/month gap. If your workload is genuinely bursty (preview environments, cron-shaped traffic, nights-and-weekends internal tools), Railway's or Fly's per-second metering can undercut even the flat box once you count the labor of running your own autoscaler-to-zero. And if your team ships features instead of operating machines, Render's forecastable $13 is arguably the cheapest line on this page measured in attention rather than dollars.

But if the workload is steady-state, always-on, and boring — the modal small SaaS, the internal tool nobody turns off — the meter is a tax on forgetting that capacity got cheap. A $5 box plus a managed-Postgres sidecar still undercuts the metered totals, and a git-push PaaS on machines you own keeps the deploy experience while deleting the per-second line items entirely.

Running the numbers and wondering what the "own the box but keep the git-push experience" option looks like in practice? 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 or price your own workload against a flat-rate fleet instead of a meter.