Dora NodaNorthflank published a Railway-vs-Fly.io teardown in 2026, and it's a genuinely useful breakdown: Railway's flat-subscription-plus-metered billing ($10/GB RAM and $20/vCPU, billed by the minute) against Fly.io's pure pay-as-you-go per-second compute and its $0.15/GB-per-30-days charge for stopped-machine storage. Its conclusion — "consistent usage favors Railway, idle-resource management favors Fly.io" — is fair as far as it goes.
It just never asks the question that actually matters once you recompute both bills line by line: what does the same workload cost on a box you own outright? Northflank can't ask that question, because Northflank is itself a hosted PaaS pitching a third metered option, not an owned one. Run the math yourself and a 4-vCPU/8GB API service that costs $176/month on Railway or $52.80/month on Fly.io runs for about $40/month on a post-price-hike Hetzner box — and that's before you get to the scenario Northflank says Fly should win, where bin-packing owned capacity beats per-second billing too.
If you're choosing a deploy target for real workloads rather than a side project, that third line changes the decision entirely — "which vendor's meter is cheaper" only matters if a meter is the only option on the table. It isn't, and the rest of this post prices out exactly what the alternative costs, tier by tier, including the one case where the vendors' own framing says a meter should win.
What Northflank's Teardown Actually Says
Strip the marketing framing and the underlying numbers are solid, so it's worth stating them precisely before recomputing anything.
Railway bills a flat plan fee (Free $0, Hobby $5, Pro $20/month) that doubles as a usage credit, then meters everything beyond it by the minute at $20/vCPU/month and $10/GB RAM/month, plus $0.05/GB egress and $0.15/GB/month for persistent volumes. There's no discount for committing to a size ahead of time — the per-unit rate is the per-unit rate whether you provision 1 vCPU or 40.
Fly.io has no base plan at all. Machines bill per second while started, at a rate set by their CPU/RAM preset, and stop billing compute the instant they're stopped. A shared-cpu-1x machine with 1GB of RAM comes out to $5.70/month running continuously — I recomputed this directly from Fly's published per-second rate ($0.00000220/second × 2,592,000 seconds/month) rather than trusting the cited figure, and it lands within a rounding error. Stopped machines are billed only for root-filesystem storage, at $0.15/GB per 30 days; attached persistent volumes bill separately at the same $0.15/GB/month rate whether the machine is running or not. Egress runs $0.02/GB in North America and Europe, up to $0.12/GB in Africa and India.
Northflank's framing — pick Railway if your load is steady, pick Fly if it's spiky — is the correct answer to the question it's asking. The question it's not asking is what either bill looks like next to a fixed-price box that never runs a meter at all.
Recomputing the Always-On Bill
Take two representative topologies and price every line — compute, egress, and volume storage — not just the headline compute rate. Assume a modest 50GB/month egress and a 10GB persistent volume at the small tier; 200GB egress and a 40GB volume at the medium tier, scaling up with the workload.
Small tier — 1 vCPU / 2GB RAM, running 24/7:
| Line | Railway | Fly.io |
|---|---|---|
| Compute | $40.00 ($20 + $20) | $10.70 |
| Egress (50GB) | $2.50 | $1.00 |
| Volume (10GB) | $1.50 | $1.50 |
| Total | $44.00/mo | $13.20/mo |
Medium tier — 4 vCPU / 8GB RAM, running 24/7:
| Line | Railway | Fly.io |
|---|---|---|
| Compute | $160.00 ($80 + $80) | $42.80 |
| Egress (200GB) | $10.00 | $4.00 |
| Volume (40GB) | $6.00 | $6.00 |
| Total | $176.00/mo | $52.80/mo |
Fly.io wins both tiers here, which lines up with Northflank's own numbers — its per-second model doesn't carry Railway's flat per-vCPU/per-GB tax. That's the entire comparison as far as either vendor's blog goes. Neither number is what an owned Hetzner box actually costs for the same topology.
The Line Neither Platform Runs
Hetzner raised cloud pricing twice in 2026 — an April adjustment of up to 37%, then a June 15 repricing that took CCX (dedicated vCPU) up 2.1-2.73x and CPX (shared vCPU, "Regular Performance") up 2.4-2.75x. Any "just self-host on Hetzner" argument built on pre-hike numbers is now stale, so here's the post-hike math, using current EUR list prices converted at roughly $1.08/€1 for the Regular Performance CPX line and Hetzner's own published USD pricing for its cost-optimized CX line.
Small tier — CPX22 (2 vCPU/4GB, ≈$21/mo) vs. CX23 (2 vCPU/4GB, $4.49/mo):
| Line | Hetzner CPX22 | Hetzner CX23 |
|---|---|---|
| Compute | $21.05 (€19.49) | $4.49 |
| Egress (50GB, under included allotment) | ~$0.00 | ~$0.00 |
| Storage (10GB × $0.062/GB) | $0.62 | $0.62 |
| Total | $21.67/mo | $5.11/mo |
Medium tier — CPX32 (4 vCPU/8GB, ≈$38/mo) vs. CX33 (4 vCPU/8GB, $6.99/mo):
| Line | Hetzner CPX32 | Hetzner CX33 |
|---|---|---|
| Compute | $38.33 (€35.49) | $6.99 |
| Egress (200GB, under included allotment) | ~$0.00 | ~$0.00 |
| Storage (40GB × $0.062/GB) | $2.48 | $2.48 |
| Total | $40.81/mo | $9.47/mo |
Hetzner bundles 20TB/month of egress in its EU locations (1TB in the US), and block storage runs €0.0572/GB/month — call both effectively free at the traffic volumes here. That leaves an honest, and mildly surprising, result: at the small tier, Fly.io's $13.20 actually beats post-hike Hetzner CPX22's $21.67. Two rounds of 2026 price increases pushed Hetzner's "Regular Performance" shared-vCPU line high enough that per-second metering wins at the low end — a real finding, not a foregone "self-hosting always wins" conclusion. It's Hetzner's cost-optimized CX line, not CPX, that still crushes both vendors at $5.11.
The picture flips as the workload grows. At the medium tier, CPX32's $40.81 undercuts Fly.io's $52.80 by 23%, because Hetzner's per-unit price improves with size (doubling vCPU/RAM from CPX22 to CPX32 costs 1.82x, not 2x) while Railway and Fly.io's metered rates scale linearly with no such discount. And CX33 at $9.47 beats every metered number on this page by more than 4x. The bigger and steadier the workload, the more ownership wins — and the cost-optimized tier wins regardless of size.
None of this is a bare-VPS comparison, either. Cluster API is the CNCF project that manages Kubernetes cluster and machine lifecycle declaratively — you describe the fleet you want in a Cluster/MachineDeployment manifest, and its controllers provision, health-check, and reconcile drift back to that spec. A Hetzner box wired up through Cluster API Provider Hetzner (CAPH) gets the same machine health checks, autoscaling MachineDeployments, and declarative reconciliation a managed control plane gives you — just running against hardware you own instead of hardware you rent by the minute.
The Case Fly.io Is Supposed to Win
Northflank's own framing says idle-resource management favors Fly.io, so the fair test is the workload that actually is idle most of the time — a staging service or a low-traffic side project running roughly 8 hours a day, scaled to zero the rest of the time. Same small-tier spec, one-third the uptime:
| Platform | Compute | Egress + storage | Total |
|---|---|---|---|
| Railway (metered, scaled to zero when idle) | $13.33 ($40 × ⅓) | $2.00 | $15.33/mo |
| Fly.io (per-second, stops on idle) | $3.57 ($10.70 × ⅓) | $2.00 | $5.57/mo |
Fly.io wins decisively here, exactly as Northflank's framing predicts — its idle-aware billing is a real advantage over Railway's flat per-vCPU/per-GB meter, which keeps charging its base rate for however many minutes the service happens to be up.
But pricing a dedicated Hetzner box for one intermittent workload is the wrong comparison, because nobody provisioning a Cluster API fleet buys one box per low-traffic tenant. A single CX33 node ($6.99/month) bin-packing eight similarly bursty tenants puts the marginal cost at $0.87/month of compute per tenant — plus storage, under $1.50/month total, still more than 3x cheaper than Fly.io's best case. Run the same bin-packing math on the pricier CPX32 node and the marginal cost lands around $5.37/month per tenant — roughly a wash against Fly.io, which is the honest result: bin-packing only decisively wins when it's paired with the cost-optimized tier, not automatically at any Hetzner price point.
What the Meter Is Actually Paying For
None of this makes Railway or Fly.io a bad deal — it makes them a different deal. Both bills include things a bare Hetzner box doesn't hand you for free: automatic TLS certificate issuance and renewal, a git-push build pipeline, zero-downtime deploys, multi-region failover, and a support line when something breaks at 3am. Building that layer yourself on top of Cluster API — an ingress controller, cert-manager for TLS, a buildpack or Dockerfile build step, a deploy/rollback controller — is real engineering time, on the order of weeks for a first working version and ongoing maintenance after that. It's fair to price that time against the dollar delta above before assuming ownership wins outright; for a team of one shipping a single side project, the $8-$40/month gap this post computes may not clear the bar against a weekend of platform-building. For a team running a fleet of tenant apps where that gap compounds across dozens of services every month, it clears the bar fast.
That gap is exactly what a Cluster-API-managed platform is supposed to close: the fixed-price economics of owned Hetzner hardware, with the git-push deploy experience and managed TLS/build pipeline a PaaS gives you, instead of a choice between hand-rolling the platform layer yourself or paying a metered vendor's markup indefinitely.
Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own, provisioned and reconciled through Cluster API. Star the repo on GitHub or deploy your first app today.
