Dora NodaThree platforms will all run your container for roughly the price of lunch — until you run ten of them, and the bill reads like a car payment. A single 1-vCPU/2-GB service costs about $12/month on Fly.io, $25 on Render, and $60 on Railway, while the same workload's share of a flat-rate Hetzner box drops to under $6 once the box is packed. That spread is the whole story of PaaS pricing in 2026: the meter you choose matters more than the workload you run.
Here is the break-even sheet, worked per platform instead of averaged across them. Same reference workload throughout — one always-on service with 1 vCPU and 2 GB of RAM — against a €16/month Hetzner cloud box (4 vCPU, 8 GB) as the owned-hardware baseline. List prices observed in September 2026; verify against live pricing pages before budgeting, because all four vendors replan regularly.
| Platform | 1 service/mo | Crossover vs one €16 box | Crossover vs HA pair (€32) |
|---|---|---|---|
| Fly.io (shared 2 GB machine) | ~$12 | ~2 instances | ~3 instances |
| Render (Standard, 1 CPU/2 GB) | $25 | 1 instance | 2 instances |
| Railway (Pro: $20 plan + ~$40 usage) | ~$60 | 1 instance | 1 instance |
| Heroku (2× Standard-2X for 2 GB) | $100 | 1 instance | 1 instance |
Two honest caveats before the rest of the post substantiates every cell. First, at n=1 you pay for the whole box, not your service's share of it — a €16 box holding one $25 Render-equivalent service saves you $9 and hands you a single point of failure. Second, the box column assumes you operate it; the hosted columns assume you don't. The crossover counts above are the raw-compute truth. The rest of this post prices the asterisks.
The per-instance bands: what each meter actually charges
The four platforms cluster into two pricing philosophies with Heroku as the historical anchor. Fixed per-service pricing (Render, Heroku) means you can forecast the bill from your service count. Usage metering (Railway, Fly.io) means you forecast from resource-seconds — cheaper at low utilization, spikier under load.
| Platform | Entry | Reference size (1 vCPU / 2 GB) | Next sizes up |
|---|---|---|---|
| Render | Free tier (spins down); Starter $7 (0.5 CPU/512 MB) | Standard $25 | Pro $85 (2 CPU/4 GB); Pro Plus $175 (4/8); Pro Ultra $450 (8/32) |
| Railway | Hobby $5 + usage; Pro $20 + usage | ~$60 on Pro ($20 + $20 CPU + $20 RAM) | Linear: $10/GB-mo RAM + $20/vCPU-mo |
| Fly.io | Per-second billing, scale-to-zero | ~$12 (shared-CPU 2 GB machine) | Scales ~linearly; dedicated CPUs from ~$31/mo |
| Heroku | Eco $5 (sleeps); Basic $7; Standard-1X $25 | $100 (2× Standard-2X at $50, 1 GB each) | Performance-M $250 (2.5 GB); Performance-L $500 |
Two rows deserve commentary. Railway's headline plan prices ($5/$20) are platform fees on top of usage — the most common misread in 2026 comparisons is quoting "$20/month Railway" against "$25/month Render" when the comparable Railway number is $60. And Heroku's Standard-2X at $50 only buys 1 GB of RAM, so a 2-GB workload needs two dynos or a $250 Performance-M; the "same per-instance band" framing from older comparisons only holds if you normalize for RAM.
The free-tier split matters for starting out, though not for the break-even math: only Render still offers a genuinely free-forever tier (with sleep). Railway and Fly.io run on trial credits that convert to pay-as-you-go, and Heroku has offered no free tier since November 2022.
Scaling the sheet: totals at 1, 3, and 10 instances
This is where fixed hardware pulls away. Hosted bills scale linearly with instance count; the box is flat until it's full. Totals below exclude egress and databases (next section prices those), and the box column uses one CPX31-class machine (€16, ~$17) up to 3 instances, then one AX42-class dedicated box (€49, ~$53, 8 cores/64 GB) for 10.
| Instances | Fly.io (~$12 each) | Render ($25 each) | Railway (~$60 each) | Heroku-equiv ($100 each) | Owned box (total) |
|---|---|---|---|---|---|
| 1 | ~$12 | $25 | ~$60 | $100 | ~$17 (whole box, mostly idle) |
| 3 | ~$36 | $75 | ~$180 | $300 | ~$17 (box ~full) |
| 10 | ~$120 | $250 | ~$600 | $1,000 | ~$53 (one dedicated box) |
Read the delta column, not just the totals. At 3 instances Render costs you $58/month more than the box; at 10 it's ~$200/month more — every month, compounding. Railway's usage meter is the steepest curve: 10 reference services burn roughly $400 in compute plus the plan fee. Fly.io stays the cheapest hosted option at every count, which is exactly why its crossover (2–3 instances) is the number Fly.io skeptics should check rather than dismiss.
But read the n=1 row honestly too. One service on a whole box means you bought 4 vCPUs to use 1, you are the on-call rotation, and a failed SSD is your outage. The hosted premium at low counts is the price of not being the ops team. The break-even question is never "which is cheaper at n=1" — it's "at what n does the monthly premium exceed the cost of becoming the ops team," which is a hiring question disguised as a pricing question.
Sensitivity: the three variables that move the crossover
The table above holds utilization, egress, and add-ons constant. Reality varies all three, and each one moves the crossover by more than the base-compute difference between any two platforms.
Egress. This is the quiet bill-doubler. Render's overage runs about $0.15/GB, Railway about $0.05/GB, Fly.io about $0.02/GB in North America and Europe — while Hetzner cloud boxes include 20 TB of traffic. At 100 GB/month of egress, Render adds ~$15 to every service's row, Railway ~$5, Fly.io ~$2, and the box adds $0. A media-heavy or API-egress-heavy workload can cross over one instance earlier than the compute sheet says; an internal tool with negligible egress never does.
Always-on versus bursty. The reference workload is always-on, which flatters fixed pricing and punishes per-second billing the least. Flip it — a preview environment, a nightly batch job, an internal dashboard used 9-to-5 — and Fly.io's scale-to-zero plus per-second billing wins by an order of magnitude: a machine running 60 hours a month costs roughly a quarter of its always-on price, while Render's $25 and Railway's plan fee charge for the hours you didn't use. If your fleet is mostly idle, the crossover recedes deep into double-digit instance counts, and the honest answer is "stay hosted, but on the per-second meter."
Databases and add-ons. Every hosted platform bills Postgres, Redis, volumes, and extra bandwidth separately from the compute rows above — Render's managed Postgres starts around $7–$15/month at the low end, Railway meters volume storage at ~$0.15/GB-month, Fly.io volumes run ~$0.15/GB-month plus snapshot costs. The box absorbs these into its flat rate (run Postgres on the same machine, or a second small one), which means a standard web-plus-Postgres-plus-Redis stack crosses over earlier than compute alone suggests. Count your add-ons before you trust the compute-only sheet.
The real complaint is unpredictability, not level
Ask teams that migrated off usage-metered platforms and few cite the average bill. They cite the variance. A traffic spike, a retry storm, a runaway worker, a misconfigured autoscaler — on Railway's meter each of these shows up as a next invoice two or three times the usual, with the explanation requiring a forensics pass over usage graphs. Fixed per-service pricing (Render, Heroku) converts that variance into a capacity decision you make in advance: the bill is instance count times tier, knowable on the first of the month. Flat-rate hardware goes one step further and converts it into a ceiling: the box costs what it costs, and a spike costs you latency or autoscaling headroom, never money.
Each model charges for its predictability in a different currency:
- Usage meters charge money for precision — you pay exactly for what you burned, and the burn varies.
- Fixed per-service tiers charge a utilization tax — you pay for the tier's full envelope whether you fill it or not (that half-empty $85 Pro instance is a 50% tax on your actual usage).
- Flat-rate hardware charges in ops burden — someone patches, monitors, replaces disks, and carries the pager, and that someone is you until you automate them away.
That last currency is the one comparison sheets usually wave off as "negligible" or "just use managed." It isn't either. A fair version: price the box, then add either your time at a defensible hourly rate or the managed-Kubernetes/control-plane layer (like a Cluster-API-based platform) that amortizes one ops investment across every service on the fleet. The crossover that survives that addition — typically a handful of always-on services, higher for bursty ones — is the number worth migrating on.
What to actually do with this sheet
If you run one or two always-on services and no database, stop here: hosted wins, pick by developer experience, and Fly.io's per-second meter is the cheapest of the three. If you run three-plus always-on services with a database, model your own row — your egress, your utilization curve, your add-ons — and take the crossover seriously, because the delta from instance four onward pays for real infrastructure every month. And if your workload is bursty, invert the whole analysis: the per-second meter is your flat rate, and the box is the expensive option.
The through-line across all four platforms is that someone operates the machine, and the bill always names who. Hosted bills name them in dollars; the box names them in pager duty. A self-hosted PaaS on hardware you own — flat-rate machines, declarative fleet management, git-push deploys on top — is the attempt to keep the flat-rate column while automating the pager-duty row down to something a small team can hold.
The per-instance bands above use list prices observed in September 2026 across Render, Railway, Fly.io, Heroku, and Hetzner; all four hosted vendors replan regularly, so re-verify before budgeting. 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.
