Dora NodaQovery's Heroku-exit writeup contains the single most quoted sentence in the 2026 repatriation debate: "The math flips as you scale. A Heroku Standard-2X dyno is $50/month and a Performance-M is $250/month; Render and Fly.io sit in the same per-instance band." It reads like a closed case for leaving. But there is a wrinkle nobody re-ran the numbers for: in June 2026, Hetzner nearly tripled the price of the dedicated cloud servers you'd actually run that fleet on. So the honest question isn't whether the math flips — it's whether it still flips, and at exactly which dyno.
We worked the full curve, one dyno to five, both sides itemized, post-hike Hetzner prices. Here is the answer up front.
The number up front: the crossover table
Same topology on both sides at every step: always-on web plus worker processes on Heroku Standard-2X dynos ($50/mo each), Postgres alongside, versus the whole thing running on one flat-rate Hetzner box in the EU. Postgres tier steps up as a growing app would force it to: Essential-0 ($5) to Essential-1 ($9) to Essential-2 ($20) to Standard-0 ($50).
| Scale | Heroku bill | Flat Hetzner box | Verdict |
|---|---|---|---|
| 1 dyno (web only) + Essential-0 | $55/mo | ~$108/mo (1x CCX23, all-in) | Heroku wins by ~2x |
| 2 dynos (web + worker) + Essential-1 | $109/mo | ~$108/mo | Dead heat — this is the flip |
| 3 dynos (2 web + 1 worker) + Essential-1 | $159/mo | ~$108/mo | Heroku +47% |
| 4 dynos (2 web + 2 worker) + Essential-2 | $220/mo | ~$108/mo | Heroku ~2x |
| 5 dynos (3 web + 2 worker) + Standard-0 | $300/mo | ~$108/mo | Heroku ~2.8x |
| Perf tier (2x Performance-M + Standard-0) | $550/mo | ~$170/mo (3x CCX13 HA) | Heroku ~3.2x |
Two things pop out. First, the flip lands absurdly early: the second always-on dyno. A side project on a single dyno is cheaper hosted than self-hosted, full stop — the box can't beat $55. The moment you add a worker, it's parity, and every dyno after that is pure meter. Second, Hetzner's hike genuinely moved the line: on pre-June pricing that same box was roughly $40 all-in, and the flip happened at dyno one. The hike bought Heroku one extra dyno of headroom. Nothing more.
The rest of this post is the receipt: both ledgers itemized, the sensitivity cases where the table above lies, and the two costs no table captures.
The Heroku ledger: dyno bands and the Postgres tax
Heroku's 2026 Cedar pricing is a ladder with wide rungs: Basic at $7, Standard-1X at $25 (512MB RAM), Standard-2X at $50 (1GB), then a chasm to Performance-M at $250 (2.5GB) and Performance-L at $500 (14GB). The ladder matters because you don't climb it smoothly — outgrowing a 1GB Standard-2X doesn't cost you $60 or $70, it costs you $250, a 5x jump for 2.5x the RAM. Teams feel this as a step function, not a slope, and the steps are where the repatriation conversations start.
The second meter is the database, and it jumps sooner. Heroku Postgres Essential-0 is $5 for 1GB, Essential-1 is $9 for 10GB, Essential-2 is $20 — and then Standard-0 is $50 for 64GB. That $20-to-$50 tier jump typically lands right around the same growth spurt that takes you from two dynos to five: more traffic, more rows, time to stop sharing a toy database. In our five-dyno row, Postgres alone ($50) costs nearly as much as the entire Hetzner box. Redis follows the same pattern from a $3 Mini. None of these prices is outrageous in isolation; the bite is that compute, database, and cache each meter independently, so a growing topology pays three markups that all scale with the same growth.
For calibration against the rest of the band: Render's 2026 paid tiers run Starter $7 (512MB), Standard $25 (2GB), Pro $85 (4GB) up through Pro Ultra $450, with managed Postgres from $6 for the small Basic tier. Same shape as Heroku — flat per-instance pricing, database metered separately — at roughly half the unit prices. Fly.io is the genuinely different animal: per-second billing where a shared-cpu-1x Machine with 256MB costs on the order of $2 a month if left running around the clock, and proportionally less if it isn't. An always-on topology on Fly lands in the same band as the table above; a sparse one doesn't, which is exactly the sensitivity case we'll get to.
The Hetzner ledger after the June 2026 hike
On June 15, 2026, Hetzner's cloud price adjustment took effect, and the dedicated CCX line — the line you'd run tenant workloads on, with dedicated vCPUs instead of shared — got dramatically more expensive. The official price table tells the story: a CCX23 (4 dedicated vCPUs, 16GB RAM) went from €31.49 to €85.99 a month in Germany and Finland, a 2.7x increase. The CCX13 (2 dedicated, 8GB) went from €15.99 to €42.99. Shared CX boxes moved far less — a CX43 is €15.99 now — but shared vCPUs are the wrong substrate for bin-packed tenant workloads, where one noisy neighbor stalls everyone on the box.
So the honest flat-box configs, post-hike, EU regions, excluding VAT:
- Single-box fleet (~$108/mo all-in): one CCX23 at $101.49 on Hetzner's own dollar list, plus roughly $7 for a 100GB volume (list is €0.0572/GB-month) and the fifty-cent IPv4. Sixteen gigabytes of RAM and four dedicated cores comfortably holds a five-dyno-equivalent topology — five 1GB processes plus Postgres — with headroom left for the control plane.
- HA fleet (~$170/mo): three CCX13s at $50.49 each ($151.47), plus a load balancer, volumes, and IPs. This is the config that survives a node loss, and it's the fair comparator for the Performance-M row, since anyone paying $250 a dyno cares about availability.
Two caveats that move these numbers. US regions (Ashburn, Hillsboro) list about a quarter higher than EU on the euro price — the CCX13 is €53.99 in the US versus €42.99 in Falkenstein — so an American team should shift the crossover about half a dyno to the right. And everything above excludes VAT, which EU businesses mostly reclaim but which still shows up on the invoice. Neither caveat changes the shape of the curve; they nudge the flip point, not the verdict.
Where the flip does NOT hold: bursty workloads and single dynos
The table assumes always-on processes, and that assumption does most of the work. Flip the utilization pattern and the meter wins.
Take preview environments: ten open pull requests, each with a review app that gets maybe two hours of real traffic a day. On per-second billing at roughly $2 a month per always-on Machine, each preview costs about sixteen cents a month in compute — the whole preview fleet is under $2. Put those same ten previews on Heroku-style per-instance pricing and you're paying for ten always-on dynos whether anyone clicks or not. Render splits the difference with 750 free hours a month and a $7 Starter tier.
The flat box, meanwhile, doesn't care about utilization at all: it costs $108 whether it's serving production or idling through the night. For sparse, bursty shapes — previews, staging, cron-like jobs, side projects — usage billing is structurally cheaper than any box, and self-hosting only wins once baseline utilization is high enough that the meter never stops.
The mirror image is row one of the table: a single $50 dyno plus a $5 database is $55, roughly half the cheapest honest box. If your topology is one process and a small database, stop reading cost comparisons and ship. The math flips as you scale — Qovery's sentence has the qualifier built in, and the qualifier is doing real work.
The cost nobody tables: ops hours and the compliance moat
Two costs never appear in either ledger, and intellectual honesty requires naming them as bounds on everything above.
The first is labor. The $108 box does not operate itself: OS patching, Kubernetes upgrades, Postgres backups you have actually tested restoring, 3 a.m. pages. A minimalist accounting — two hours of engineer time a month at any plausible fully-loaded rate — exceeds the entire Heroku bill at every row of the table. Self-hosting wins on infrastructure spend and can still lose on total spend for a team with no platform muscle. This is precisely the gap a self-hostable PaaS layer exists to close: the box is cheap, and the automation that makes the box boring is the actual product.
The second is compliance. Render's least-copyable edge was never price — it was published posture: SOC 2, ISO 27001, HIPAA-eligible Postgres with point-in-time recovery, on instance sizes up to 32GB. A regulated team rebuilding that on owned hardware pays auditors, not servers, and no crossover table captures it. If you handle health data or sign enterprise DPAs, the meter isn't just compute; it's evidence, and evidence is expensive to manufacture yourself.
Run the curve for your topology
The general method behind the table fits on an index card. One: count your always-on processes and price them at your platform's per-instance band — $50 steps on Heroku, $25 on Render, per-second on Fly. Two: price the database tier jump your data volume actually forces, not the tier you're on today; the $20-to-$50 Postgres step is where hosted bills quietly double. Three: compare the total against one CCX23 (~$108/mo all-in, EU) and ask whether your baseline utilization keeps that box more than half full. If yes, the meter has already crossed the box, and every dyno after the second is a donation.
Qovery's sentence survives Hetzner's hike with exactly one amendment: the math flips as you scale, starting at dyno two instead of dyno one.
Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own. If the curve above has you pricing out the flat-box column, star the repo on GitHub or deploy your first app today.
