Dora NodaThe cheapest price on a PaaS pricing page is never the price you pay. Railway's Hobby plan says $5/month — and includes $5 in usage credits. Fly.io's smallest Machine lands around $2/month metered per second with no base fee. Both sound cheaper than a €3.79 Hetzner CX22. Then you add the two things every real app needs — persistent disk and bandwidth — and the bill moves.
Here is the answer up front for a single always-on service (512 MB RAM, 0.5–1 vCPU, 10 GB volume, 50 GB egress, 730 hours/month):
| Line item | Railway Hobby | Fly.io shared-cpu-1x 256MB | Hetzner CX22 (2 vCPU / 4 GB / 40 GB) |
|---|---|---|---|
| Base compute (always-on) | $4.13 (0.5 GB + 0.5 vCPU blended) | $2.02 | €3.79 (~$4.15) |
| Plan / subscription | $5 — but $5 credits offset compute | $0 | Included |
| Volume (10 GB) | $1.50 ($0.15/GB) | $1.50 ($0.15/GB) | Included (40 GB) |
| Egress (50 GB) | $2.50 ($0.05/GB) | $1.00 — $2.00 (NA/EU $0.02, APAC $0.04) | Included (20 TB) |
| Total before credits | ~$8.13 | ~$4.52 — $5.52 | ~$4.15 |
| Total after credits / bundling | ~$3.13 (Hobby credits cover first $5 of compute+volume+egress) | ~$4.52 — $5.52 | ~$4.15 |
| At 200 GB egress | ~$10.63 | ~$6.52 — $11.52 | ~$4.15 (still) |
| At 500 GB egress | ~$25.63 | ~$12.52 — $23.52 | ~$4.15 (still) |
Railway's headline number wins inside the credit envelope — barely. Fly.io wins when egress stays low and regional. Hetzner wins the moment traffic grows, because its 20 TB is not a line item at all. The rest of this post unpacks how each meter actually works and where per-second billing stops being cheaper than flat hardware.
What "$5" and "$2" Actually Buy
Understanding why a comparison like this surprises people starts with what each vendor is selling under that headline.
Railway: a subscription that turns into credits
Railway's 2026 Hobby plan is $5/month with $5 in included usage credits. There is also a 30-day trial with a one-time $5 credit and a cap around 1 GB RAM / 2 vCPU per service to try before paying. Hobby raises that cap to 48 vCPU / 48 GB RAM per service and 5 GB of volume — not relevant for a cheap singleton, but it signals the plan is not deliberately throttled.
Once credits run out, Railway meters everything per minute:
- RAM: $10 / GB / month ($0.000231 / GB / minute)
- vCPU: $20 / vCPU / month ($0.000463 / vCPU / minute)
- Volume storage: $0.15 / GB / month
- Network egress: $0.05 / GB
- Ingress: free; private networking between services: free for data transfer but still runs through the machines
The key detail: the $5 Hobby fee is not on top of usage. It is usage. Railway puts $5 of credits in your account and burns them at the rates above. A 256 MB service on a single vCPU burning ~$0.30–$0.50 of credits per week fits comfortably inside one Hobby credit pool. Two services, or one meatier one, blow past it and the per-minute meters start billing real dollars.
Fly.io: pay for seconds, no base fee — and a longer receipt
Fly.io has no monthly plan to buy. You pay for what you run, by the second. The canonical cheap always-on reference — a shared-cpu-1x with 256 MB — is widely quoted at ~$1.94–$2.02/month region-dependent if left running 730 hours. That number is real and is the reason Fly.io feels unbeatable for a minimal box.
But the rest of the receipt is longer than most pricing-page skims notice:
- Volume: $0.15 / GB / month, same sticker as Railway
- Egress: tiered by region — $0.02/GB in North America and Europe, $0.04/GB in Asia Pacific / Oceania / South America, $0.12/GB in parts of Africa
- Egress IPs: app-scoped IPv4 at $3.60/month per IP billed since January 1, 2026 (IPv6 not billed independently). Some apps need one; many do not — but if you do, it erases the compute savings alone.
- Stopped-machine rootfs: $0.15 / GB per 30 days for the image kept warm while a machine is stopped (recently made explicit)
- Volume snapshots and inter-region private networking: both started metering in early 2026 — private networking now bills at Machine rates when traffic crosses regions
The metered-per-second shape is genuinely cheap at low utilization. It is also genuinely wide: each primitive gets its own meter, and each new meter turns a formerly bundled dimension into a line item.
Hetzner CX22: a fixed number that does not move
Hetzner Cloud's CX22 at €3.79/month (~$4.15) gives you 2 vCPU, 4 GB RAM, 40 GB NVMe SSD, and 20 TB of included traffic in FSN1/HEL1/NBG1. No per-GB egress meter, no per-GB volume add-on inside the 40 GB, no second bill for the IPv4 if you bring your own floating IP. The hardware is yours whether you use it or not — which is also its honest weakness for bursty workloads, covered below.
The Worked Bill: One Service, 10 GB Volume, 50 GB Egress
Take a representative solo-dev stack: a small API plus its database file or object sidecars, serving enough traffic to push 50 GB of outbound data in a month. Not viral, not idle — a real hobby-turned-side-project.
Common assumptions kept identical for all three legs:
- Compute footprint: 0.5 GB RAM, 0.5 vCPU equivalent, always on (730 hours)
- Persistent volume: 10 GB
- Egress: 50 GB outbound to the internet
- Region: North America / Europe (so Fly.io gets its cheapest $0.02 tier; the penalty case is shown separately)
Railway — best case inside the credit
| Item | Math | Cost |
|---|---|---|
| Compute (0.5 GB RAM) | 0.5 × $10/GB | $5.00 |
| Compute (0.5 vCPU) | 0.5 × $20/vCPU | $10.00 |
| But blended per-minute for 512 MB/0.5 vCPU | ~$4.13/mo continuous | $4.13 |
| Volume 10 GB | 10 × $0.15 | $1.50 |
| Egress 50 GB | 50 × $0.05 | $2.50 |
| Subtotal before credits | ~$8.13 | |
| Less Hobby included credits | -$5.00 | |
| Payable on Hobby | ~$3.13 |
If you size down to 256 MB / shared vCPU equivalent, the compute line drops and the entire service stays inside the $5 Hobby credit — effectively $5 flat. That is Railway's genuine best case and why a single tiny service feels free. The moment you add a second service (a worker, a preview), you pay the full per-minute rates with no second pool of credits — Hobby covers one workspace's usage, not one service's.
Fly.io — cheapest line-by-line
| Item | Math | Cost |
|---|---|---|
| Machine (shared-cpu-1x 256 MB, 730h) | region-dependent | ~$2.02 |
| Bump to 512 MB (+256 MB) | ~$1.19/mo (512 MB class) | +~$1.00 if needed |
| Volume 10 GB | 10 × $0.15 | $1.50 |
| Egress 50 GB (NA/EU) | 50 × $0.02 | $1.00 |
| Egress 50 GB (APAC/SA) | 50 × $0.04 | $2.00 |
| Egress IP (if needed) | per IPv4 | +$3.60 |
| Total NA/EU, no extra IP, 256 MB | ~$4.52 | |
| Total NA/EU, no extra IP, 512 MB | ~$5.52 |
No credits to reason about — what you see is what is billed, per second. The NA/EU number is extremely competitive. Put users or yourself on the wrong side of Fly.io's egress regions, or add a dedicated IPv4, and it jumps.
Hetzner CX22 — flat
| Item | Cost |
|---|---|
| CX22 (2 vCPU / 4 GB / 40 GB / 20 TB) | €3.79 (~$4.15) flat |
| Volume 10 GB | Included within 40 GB |
| Egress 50 GB | Included within 20 TB |
| Total | ~$4.15 |
Two extra vCPUs and 3.5 GB of RAM come along with the box whether you need them or not. That slack looks wasteful on paper but is exactly what absorbs the next service, sidecar, or traffic spike without a new meter starting.
The table from the introduction is just these three subtotals collapsed to one row each. Railway wins inside one credit envelope at low egress; Fly.io wins when egress is low and regional; Hetzner wins by not having an egress dimension to scale.
Where the Meter Shape Flips: Sensitivity, Not One Number
A single scenario is useful but misleading if you stop there. The variable that drives the delta is almost always egress, not compute.
Egress sweep (fixed compute + 10 GB volume)
| Monthly egress | Railway (after $5 credit) | Fly.io NA/EU | Fly.io APAC | Hetzner CX22 |
|---|---|---|---|---|
| 10 GB | ~$1.13 | ~$3.72 | ~$3.92 | ~$4.15 |
| 50 GB | ~$3.13 | ~$4.52 | ~$5.52 | ~$4.15 |
| 100 GB | ~$5.63 | ~$5.52 | ~$7.52 | ~$4.15 |
| 200 GB | ~$10.63 | ~$7.52 | ~$11.52 | ~$4.15 |
| 500 GB | ~$25.63 | ~$13.52 | ~$23.52 | ~$4.15 |
Two takeaways:
- Railway's $0.05/GB egress is the steepest of the three — 2.5× Fly.io NA/EU. It is the bill line that recaptures the compute-credit savings fastest.
- Fly.io stays competitive to ~100–150 GB in NA/EU and then also hands the lead to Hetzner. In APAC/SA regions its crossover drops to ~60–80 GB.
The other axis: utilization shape
Flat hardware overpays when you do not need always-on — and per-second wins by a mile there:
- An app that runs 1 hour a day costs Fly.io roughly $0.07/month in compute (shared-cpu-1x 256 MB) versus $4.15 for a CX22 sitting idle 23 hours. Scale-to-zero Machines and Railway's serverless sleep primitive are genuinely cheaper for bursty or scheduled workloads.
- The entire comparison above assumes 730/730 hours always-on. That is the expensive shape for metered billing. If your workload auto-sleeps or you can suspend it, metered-per-second is the right model and not an apples-to-apples competitor to a fixed box.
Volume sensitivity is small — until it is not
At 10 GB, volume is a rounding error ($1.50 on both PaaS legs, $0 on Hetzner). At 100 GB, it is $15 of new bill on Railway and Fly.io each — and still $0 on the CX22 until you exceed 40 GB and need CX32/CPX upgrades. For database-heavy apps, the volume line alone can flip the rank.
The Hidden Lines Nobody Puts in the Headline
Beyond the three core meters, three 2026 billing changes deserve explicit attention because they do not show up in older comparisons:
Railway — the documentation is now explicit that egress is easy to accidentally double. Connecting to your Railway Postgres over its public URL instead of the private URL counts the same bytes as egress twice. Private networking avoids it, but only if you remember to use it. Real-time usage dashboards help, but the meter is still there.
Fly.io — at least four new-ish meters since early 2026:
- App-scoped egress IPs ($3.60/mo per IPv4) — billing started January 1, 2026.
- Volume snapshots — now metered separately (January 2026); routine daily backups of a 10 GB volume add a recurring line many earlier cost posts treated as free.
- Inter-region private networking at Machine rates — since February 2026, WireGuard mesh traffic between regions is no longer treated as free east-west fabric.
- Stopped-machine rootfs — $0.15/GB per 30 days for keeping a machine image warm while stopped; not large, but it turns "scale to zero = zero cost" into "near-zero cost plus a storage line."
None of these is dishonest — they are all documented. They are just not in the "$2 box" number your team budgeted off of six months ago.
Hetzner — the honest weakness is capacity, not price. Start mid-2026, Hetzner Cloud restricted new server creation for some customers and regions citing hardware availability, and it raised prices three times (April setup fees, April cloud hikes 30–38%, June CCX/CPX dedicated-vCPU jumps). A flat-rate box is still flat — but "flat and available" depends on the provider having capacity to sell you the box in the first place. Multi-location and multi-type fallback in your provisioning layer matters more now than it did two years ago.
How to Choose Without Lying to Yourself
Pick Railway Hobby when: you run one or two small services, egress stays under ~30 GB/month, and the $5 credit covers your footprint. The experience is strong for side projects precisely because that credit is the product — you are not managing machines, you are burning a small allowance. Watch egress the moment your app serves images, video, or API payloads at scale.
Pick Fly.io when: you want per-second elasticity without a monthly subscription, you can run close to your users in NA/EU to keep egress at $0.02, and your workload benefits from Machines autoscaling, suspending, or scaling to zero. Watch egress region, snapshot retentions, and whether you actually need a dedicated IPv4.
Pick Hetzner (or any bandwidth-included box under Cluster API) when: you want predictable billing that does not move with traffic, you run multiple services/containers on one host, or your workload needs persistent volumes and steady outbound bandwidth. The CX22 is effectively a team-size slice — 2 vCPU and 4 GB host more than one service, so the second app is free in marginal cost terms while it would add a second meter on any usage-based PaaS. The trade is operational: you own the OS, updates, and lifecycle — or you put a platform like Cluster API on top of it and treat the box as a node, not a pets-and-cattle project.
For the specific scenario this post scoped — one always-on service, 10 GB disk, 50 GB out — the rank is:
- Railway inside credits (~$3.13) — narrowly cheapest, but only inside one service + one credit pool
- Hetzner CX22 (~$4.15) — flat and insensitive to traffic
- Fly.io NA/EU (~$4.52) — within a dollar, and wins outright if utilization drops
Raise egress to anything a real product serves — 200 GB — and the rank becomes Hetzner, then Fly.io NA/EU, then Railway, by a widening gap.
Bottom Line
Pricing pages optimize for the demo. Real bills optimize for egress and disk — the two lines that compound with success while compute stays flat. Railway and Fly.io both price those lines explicitly; Hetzner bundles them into the metal. The cheapest always-on sticker price is not a lie, but it is a partial truth calibrated to an idle app with no data to serve.
Running the numbers for your traffic before you migrate is the only pricing page that matters — and it takes ten minutes with the three rates above. If that exercise points you toward owned hardware but you still want a PaaS-shaped workflow (push a repo, get HTTPS, no hand-rolled VM ops), that is the gap a self-hosted platform exists to close.
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.