Dora NodaPickuma's 2026 Fly.io review contains the single most-quoted price comparison in this year's Heroku-migration discourse: a Heroku web dyno with 512 MB of RAM costs $7 per month per process, while Fly.io's equivalent shared-cpu machine costs approximately $3.88 per month. Read quickly, that line says Fly.io is 45 percent cheaper than Heroku. Read carefully, it prices one process — and nobody runs one process.
This post works the comparison all the way to the invoice for a team serving users in about two regions, deciding whether they need Fly.io's 37-region edge or just need off Heroku. Same workload on all three platforms — one web process, one worker, one Postgres, two regions, roughly 100 GB of egress — at October 2026 list prices. Here are the assembled totals; the line items follow.
| Heroku (Basic tier) | Fly.io (self-run Postgres) | Fly.io (Managed Postgres) | Hetzner (one box) | |
|---|---|---|---|---|
| Web + worker + Postgres, ~2 regions, 100 GB egress | ~$23/mo | ~$30/mo | ~$53/mo | ~$5–10/mo |
| Regions you can actually serve | 1 (US or EU) | 2 of 37 | 2 of 37 | 1–2 of 6 |
| Who runs Postgres | Heroku | You | Fly (thin layer) | You |
The $3.88 machine is real, and it still loses to the $7 dyno at this tier once the database enters the picture — while the flat-hardware row undercuts both by two-thirds. The rest of this post shows the math, the sensitivity, and the operational overhead the unit prices hide.
The worked comparison: one web, one worker, one Postgres, two regions
Fix the workload first so every column prices the same thing: a small production app with a web process and a background worker, each needing about 512 MB of RAM, backed by a single small Postgres with roughly 10 GB of data, serving traffic from two regions (say, US East and Western Europe), moving about 100 GB of egress a month. Nothing exotic — the canonical "we outgrew the hobby tier" shape.
Heroku: ~$23 a month, one region. Two Basic dynos at $7 each — web and worker are separate processes, each billed per process — plus Postgres Essential at roughly $9 a month for the entry tier. That is $23 for compute and database with builds, deploys, Postgres management, and connection handling all included. The catch the table above already names: Heroku's Common Runtime runs in the US and EU only, and a Basic-tier app lives in exactly one of them. A team "serving two regions" on Heroku is really serving one region and accepting transatlantic latency for the other half of its users. Stepping up to production-grade Heroku — two Standard-1X dynos at $25 each plus Standard-0 Postgres at $50 — takes the same workload to roughly $100 a month before add-ons, which is why the migration conversation exists at all.
Fly.io with self-run Postgres: ~$30 a month, two regions. Two shared-cpu web machines at $3.88 each (one per region), one $3.88 worker in the primary region — workers rarely need geographic duplication — plus a self-managed Fly Postgres single-node instance at roughly $15 a month including its volume, volumes at $0.15 per GB-month, and 100 GB of North America/Europe egress at $0.02 per GB, about $2. Total: just under $30. Note what that $30 buys that Heroku's $23 does not: machines in two genuinely different regions behind anycast routing, and per-second billing that drops toward zero if workloads can auto-stop. Note what it stops buying: anyone to run your database.
Fly.io with Managed Postgres: ~$53 a month, two regions. Swap the self-run database for Managed Postgres at roughly $38 a month and the total lands near $53 — more than double Heroku's Basic-tier stack. The managed tier buys automated backups and point-in-time restore, but per Pickuma's testing it still lacks connection pooling, query monitoring, and automated failover. You configure pooling yourself via PgBouncer or your framework's pool and monitor through your own observability stack. That is the thin-management-layer caveat in concrete form: the $38 line item does not restore the Heroku property of "never think about Postgres."
Hetzner: ~$5–10 a month, flat. One CX23 cloud server — 2 shared vCPUs, 4 GB of RAM, 40 GB of NVMe — at roughly €4.75 a month post-June-2026 pricing, comfortably holds this workload's web, worker, and Postgres with headroom to spare. A CPX22 with double the disk runs roughly €9.51. Either way, 20 TB of included traffic makes the 100 GB egress line item exactly zero, and there is no per-region meter at all — a second box in another of Hetzner's six locations doubles the bill to $10–20 and still undercuts every managed row. The price of flat is total ownership: builds, deploys, Postgres, backups, and failover are all yours.
Two deltas carry the argument. First, the unit-price inversion: Fly.io's compute is 45 percent cheaper per process ($3.88 vs $7), yet its assembled two-region stack costs 30 percent more than Heroku's ($30 vs $23) once a self-run database joins — and 130 percent more with managed Postgres. The database, not the dyno, is the price of leaving. Second, the edge-at-two-regions gap: the Fly.io stack costs $20–25 a month more than the Hetzner box while consuming 2 of 37 regions' worth of edge capability — the anycast network, the WireGuard mesh spanning dozens of metros, the per-region scheduling — of which a colocated two-region app with a single-region database uses a thin slice.
What moves the answer
A single worked example proves nothing unless you know which inputs flip it. Four variables matter, in descending order of leverage.
Postgres tier is the ranking flip. Moving Heroku from Essential (~$9) to Standard-0 ($50) adds $41 and jumps its row to roughly $64 even before touching dynos — at which point Fly.io with self-run Postgres ($30) is suddenly the cheap managed option. Conversely, any team that needs genuine managed Postgres with pooling and failover finds neither vendor cheap: Heroku Standard-0 starts at $50 for the database alone, and Fly.io's managed tier at $38 still omits pooling and failover. If your database needs are production-shaped on day one, price the database first and let it pick the platform.
Egress volume widens or collapses the managed gap. At 10 GB a month, egress is noise on every platform ($0.20 on Fly.io, a few dollars on Heroku add-on bandwidth, zero on Hetzner). At 100 GB, Fly.io's $0.02 per GB in North America and Europe keeps the line item near $2 — but serve that traffic from Asia-Pacific or South America and the $0.04 tier doubles it, and a second region's cross-region transfer starts appearing as real money. At 500 GB, Fly.io egress alone ($10–20 depending on region mix) approaches the entire Hetzner box, while Hetzner's 20 TB inclusion still prices it at zero. Heavy-egress two-region apps are where flat hardware stops being merely cheaper and starts being structurally different.
Auto-stop rewards the bursty, punishes the steady. Fly.io's per-second billing with auto-stop machines means a staging environment or a bursty internal tool can cost a fraction of its always-on price — Pickuma measured suspended-machine wake at about 1.8 seconds for Go and 3.4 seconds for Node.js. But the workload in this post is always-on production: web and worker running 24/7, where per-second billing converges to the monthly rate and the wake-latency question never arises. If your app cannot tolerate 1–4 seconds of wake-up latency, you keep machines running and pay the full $3.88 each — which is exactly what the table assumes.
Region count is linear on Fly.io, flat everywhere else. One region instead of two saves one $3.88 machine — a 13 percent cut to the $30 stack. Six regions, as in Pickuma's own test deployment, adds four more machines plus cross-region replica costs and pushes the Fly.io row past $50 even with self-run Postgres. Heroku and Hetzner barely move: Heroku cannot express the difference at all, and Hetzner charges per box regardless of which of its locations you pick. The honest reading is that Fly.io's region count is a dial you pay for per click, while its competitors sell you a fixed geography.
The edge overhead you pay at two regions anyway
The sharpest claim for a two-region team is that it pays the same edge-first operational overhead as a thirty-region one. Pickuma's review substantiates it line by line, and each item below is work Heroku does for its $7 that Fly.io returns to you at any region count.
Machine sizing is per-region capacity planning. There is no dyno slider; you pick CPU/RAM presets per machine, per region, in fly.toml or via CLI, and region-level scaling is primarily a CLI operation — Pickuma found the dashboard trails the CLI for deployment, scaling, and volume management. A two-region app means two scaling decisions, two machine-size choices, and autoscaling rules you write yourself. Heroku's $7 dyno never asks what a region is.
Volumes are pinned to one region with no automatic replication. Fly.io volumes are NVMe-backed SSDs attached to specific machines at $0.15 per GB-month, and a volume in Amsterdam is accessible only from Amsterdam machines. Your Postgres data lives in one region; the second region's app server talks to it over the WireGuard mesh or you pay for a read replica — a separate machine with its own cost. For a two-region team this means the database geography question arrives on day one, not at scale: colocate and accept single-region state, or replicate and pay per copy.
The Postgres management layer is thin at every tier. Self-run Fly Postgres provisions machines, configures replication, and provides backup tooling — pooling, query monitoring, and automated failover are yours to build. Managed Postgres at $38 adds backup automation and point-in-time restore but still omits pooling, monitoring, and failover. Either way, the Heroku property of "attach a database and stop thinking" does not transfer; the migration budget needs a PgBouncer line, a monitoring line, and a failover-runbook line that the $3.88-vs-$7 framing never mentions.
Cross-region latency forces colocation or paid replicas. Same-region mesh overhead is under 2 milliseconds, but cross-region queries pay full geography — roughly 200 milliseconds between Tokyo and Amsterdam, 100 milliseconds between Chicago and Amsterdam in Pickuma's measurements. A two-region app with a single-region database either colocates chatty services with the data (surrendering half the edge benefit) or stands up read replicas (paying per replica). The mesh is excellent infrastructure; it is not a substitute for deciding where your data lives.
None of this is an argument that Fly.io is badly built — Pickuma's verdict is explicit that it beats every PaaS comparator when geographic distribution actually matters. It is an argument that the overhead is fixed cost, not marginal cost: the second region does not cost 2/37ths of the platform's complexity. It costs nearly all of it.
Where the edge honestly wins
The carve-out matters because the post would be dishonest without it. Three workloads genuinely earn Fly.io's edge premium, and Pickuma's measurements show why.
First, genuinely geo-distributed reads: an API with users in six-plus metros where anycast routing plus regional machines cuts hundreds of milliseconds per request. Pickuma's six-region deployment — Amsterdam, Tokyo, Sydney, São Paulo, Chicago, Singapore — is the shape where 37 regions stop being a brochure number and start being latency math. Second, bursty, high-compute workloads: per-second machine billing with 80–140 ms Go cold starts rewards intermittent heavy compute (image processing, PDF generation, inference) that would idle expensive always-on dynos elsewhere. Third, private cross-region networking: the organization-wide WireGuard mesh with private IPv6 and ~1.5 ms per-hop overhead, with no VPC or VPN to configure, is the feature reviewers consistently call best-in-class.
The test for a migrating team is simple: if your database fits in one region, your users cluster in two timezones, and your processes run 24/7, you match none of the three shapes. You are paying edge prices for dyno needs.
The migrator's decision rule
For a team on Heroku serving about two regions and deciding what "off Heroku" means, the worked numbers compress to a rule with three branches.
If you need the edge, buy the edge. Real multi-region latency requirements, bursty compute that benefits from per-second billing, or private mesh networking across regions: Fly.io at ~$30–53 for the reference stack is the correct purchase, and the operational overhead above is the real price of capabilities Heroku cannot sell you at any tier.
If you need off Heroku in one or two regions, price the database first. At Basic-tier database needs, Heroku's own $23 stack is still the cheapest managed answer — the $3.88 machine does not beat the $7 dyno once Postgres is in the frame. At production-tier database needs, Fly.io with self-run Postgres ($30) undercuts Heroku's ~$100 Standard path by two-thirds, provided you budget the pooling, monitoring, and failover work the thin layer omits.
If you can own the box, the meter disappears. The Hetzner row — ~$5–10 a month all-in, 20 TB of traffic included, no per-region or per-process billing — is the honest baseline every managed quote should be read against. What it costs instead is engineering time: builds, deploys, Postgres operations, and backups become your roadmap, not your invoice.
Most two-region migrators land in the second branch and discover the decision was never $3.88 versus $7. It was who runs Postgres, how many regions your data actually lives in, and whether your traffic belongs on a meter or on flat hardware. Answer those three, and the platform picks itself.
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.
