Qovery's Heroku-Alternative Price Table, Recomputed: What Render, Railway, and Fly.io Really Cost for One Small App

Qovery's September 2026 Heroku-alternatives comparison did something rare: it dated every price and linked every vendor page. Render from $7 a month, Railway from $5, Fly.io from $2.02. All true, all sourced — and all nearly useless for budgeting, because nobody ships a production app on the entry line alone. So I recomputed the same small production stack on each meter, plus one flat-rate Hetzner box for reference. Here is the answer up front, with the full line-item math below.

The entry-price ranking survives. The entry-price magnitudes do not: the real spread is $10 to $39, and the two usage-metered platforms can trade places with Render depending on how much CPU and RAM your app actually burns. That crossover — not the headline table — is what decides your bill.

What Qovery's September table actually says​

The source is Qovery's September 2, 2026 comparison of five Heroku alternatives — Qovery, Render, Railway, Fly.io, and Coolify — with entry prices explicitly pulled from each vendor's own page as of September 2026. Its most useful move is splitting the field into three ownership models instead of ranking five logos on one axis:

• Hosted PaaS (Render, Railway, Fly.io): your app runs on their infrastructure. More cost per workload, zero ops.
• BYOC (Qovery): runs inside your own AWS, GCP, Azure, Scaleway, or existing Kubernetes account. A platform fee on top, but the cloud bill — and any committed-use discounts — stay in your name.
• Self-hosted (Coolify): free Apache-2.0 software on servers you own and operate. Almost no license cost, highest engineering cost.

The hosted entry prices, quoted from the article: Render web services from $7 a month with managed Postgres from $6, Railway at $5 a month on Hobby and $20 on Pro before usage at roughly $20 per vCPU and $10 per GB of RAM, and Fly.io from $2.02 a month for a shared-cpu-1x Machine with 256 MB of RAM. Qovery's own Business plan starts at $2,999 a month billed annually — a platform fee for teams that outgrew Heroku, not a small-app price, so it sits outside this recompute. Coolify is $0 plus whatever server you put under it.

Qovery also prices the thing self-hosting advocates leave out: the work. A DevOps or SRE engineer at roughly $150,000 median total US compensation is about $72 an hour, so eight hours of monthly maintenance is around $576 in engineering time — more than twenty times a $24 VPS. Keep that number in your head. It is the thumb on the scale for everything that follows.

The yardstick: one small production app​

Entry prices describe one component. A production app is a stack. The reference app for this recompute is deliberately boring — the median small thing teams actually run:

Why these sizes: 512 MB is Render's Starter web tier and Fly.io's smallest practical web Machine, so the comparison starts where the vendors' own entry tiers live. The database gets the smallest production-suitable option on each platform rather than the cheapest demo tier. Egress at 50 GB is a typical small SaaS or content-backed app — enough that per-GB metering shows up, not enough to be a pathological bandwidth story. Scale-to-zero and growth scenarios get their own section below, because that is exactly where the ranking flips.

The recompute, line by line​

All rates are September 2026 vendor or vendor-adjacent sources, noted per line. Totals exclude VAT and exclude your time — time gets priced separately in the next section but one.

Render: ~$32. Starter web service (512 MB) at $7, Basic Postgres (256 MB) at $6 plus 10 GB of storage at about $0.25 per GB-month ($2.50), Key Value Starter at $10, and billable egress at roughly $0.15 per GB (about $6.75 on 45 billable GB after a small included allowance, per the worked example in Railway's 2026 pricing comparison). Total: $7 + $6 + $2.50 + $10 + $6.75 = $32.25. Note the database step-up hiding behind this: if your Postgres needs a full GB of RAM rather than 256 MB, Render's 1 GB tier runs about $19, which takes this stack to roughly $45. That single tier jump is the most common way a Render bill surprises people.

Railway, lean actuals: ~$23. Railway meters compute per second at about $20 per vCPU-month and $10 per GB-month, volumes at $0.15 per GB-month, and egress at $0.05 per GB. A small app idling between requests might actually burn 0.1 vCPU on web ($2) plus 0.5 GB ($5), 0.1 vCPU on Postgres ($2) plus 0.5 GB ($5), a small Redis at about $4.50, 10 GB of volume storage ($1.50), and 50 GB of egress ($2.50). Usage totals $22.50. The $5 Hobby subscription includes $5 of usage credit and the $20 Pro subscription includes $20, so the bill lands at about $22.50 either way — above both credit floors, below both sticker-plus-usage fears.

Railway, reserved-equivalent actuals: ~$39. Now assume the app actually uses what the yardstick reserves: web at 0.5 vCPU ($10) plus 0.5 GB ($5), Postgres at 0.5 vCPU ($10) plus 0.5 GB ($5), the same Redis ($4.50), storage ($1.50), and egress ($2.50). Usage totals $38.50, and the subscription credits barely dent it. Same app shape, same vendor, $16 a month apart — the entire difference is the gap between provisioned capacity and burned capacity. This is the metered-pricing lesson in one number: Railway charges for what you burn, so your utilization curve is your bill.

Fly.io: ~$14. Per-Machine billing: a shared-cpu-1x with 512 MB at about $3.32 always on, a 1 GB Postgres Machine at about $5.70 plus a 10 GB volume at $0.15 per GB-month ($1.50), a 256 MB Redis Machine at about $2.02, and 50 GB of egress at $0.02 per GB in North America and Europe ($1). Total: roughly $13.54.

The honest asterisk: Fly Postgres runs as Machines you operate — backups, failover posture, and version upgrades are your runbook, not a managed-DB SLA. You are comparing a self-operated database at $7.20 against Render's managed one at $8.50. Price them as the same thing and you will mislead yourself.

Hetzner flat box: ~$10. A CX33 shared-vCPU instance (4 vCPU, 8 GB RAM) at €8.49 under the June 2026 price adjustment, plus €0.50 for the primary IPv4 — about $10 all in. Postgres, Redis, and the web service all live on the one box with gigabytes of headroom left over, and 50 GB of egress is noise against 20 TB included. The price does not move when your app uses more of the machine; it moves only when you outgrow the box. The asterisk here is the mirror of Fly's: everything above the hypervisor — OS patching, Postgres backups, TLS renewal, monitoring, on-call — is yours, which is where Qovery's $576-a-month-for-eight-hours math bites.

Where the meter flips the ranking​

The baseline ranking — Hetzner, Fly.io, lean Railway, Render, busy Railway — holds only at the yardstick. Three variables reorder it, and each one maps to a growth story teams recognize.

RAM growth punishes meters, not boxes. Double the app's memory footprint to 2 GB of working set and Railway adds about $15 a month at $10 per GB while Fly.io adds about $7.50 at roughly $5 per GB. Render likely forces a tier jump on web or database. The Hetzner box absorbs it for $0 — the CX33 still has headroom. Somewhere between 2 and 4 GB of steady-state RAM, even lean Railway crosses Render's flat $32, and the "cheap metered" story inverts: meters reward the small and punish the growing, while the flat box is indifferent until the next size up.

Egress growth punishes per-GB meters hardest. At 500 GB a month instead of 50, Fly.io adds $9 (still cheap at $0.02 per GB), Railway adds about $22.50 at $0.05, and Render-style $0.15 metering would add roughly $67 — more than doubling that stack. The Hetzner box adds $0 inside its 20 TB allowance. This is the single biggest ranking flip in the whole exercise: a media-heavy or API-heavy app that looks mid-pack at 50 GB can make usage-metered egress the largest line on the bill at 500 GB. If your app serves bytes, price egress before you price compute.

A second service flattens the hosted-vs-box gap in opposite directions. Add a background worker at web size: Render adds another $7-plus, Fly.io adds another ~$3.32 Machine, Railway adds whatever the worker burns (often small — workers idle), and the Hetzner box adds $0. But add headcount instead of services and the flat box loses ground another way: every hour of ops toil is $72 of engineer time, and two services have roughly twice the runbook surface of one.

Scale-to-zero is the one flip that favors meters. The yardstick assumes always-on production. Staging, preview environments, and side projects that sleep are a different game: Fly.io's autostop and Railway's per-second billing drop idle costs toward just disk, while Render's Starter and the Hetzner box charge the same sleeping or serving. Teams running many small environments — a preview app per pull request — can easily spend less on meters than on one more flat box. Price your environments, not just your production stack.

What entry prices can't show, and who should pick what​

Three things never appear in an entry-price table and dominate the real decision.

First, managed databases are not interchangeable with database-shaped Machines. Render's managed Postgres buys automated backups, point-in-time recovery, and a version-upgrade path somebody else tests. Fly.io's Postgres and any Hetzner-hosted Postgres buy control and a lower number — plus a runbook. The $8.50-vs-$7.20 gap between them is not savings; it is the down payment on your own DBA practice. New teams consistently underprice this and pay for it during their first real incident.

Second, the ops-time crossover dwarfs every infra crossover above. The gap between the cheapest and priciest recomputed stack is about $29 a month. One hour of engineer time at Qovery's $72 figure is more than double that. If self-operating the flat box costs you even one extra hour a month versus a hosted platform, the infra savings evaporate — which is why "Hetzner wins on price" is true on the invoice and frequently false on the P&L. The honest self-hosting pitch is control, data gravity, and committed-spend leverage, not saving $29.

Third, preview environments and team workflows are priced in toil, not dollars. Render and Railway include per-PR environments; Qovery's BYOC pitch is Heroku-style workflows with the bill in your own account; Coolify and raw boxes need you to build or wire that yourself. For a team shipping daily, that workflow gap is worth more than any row in the cost table.

So the verdict is not a ranking but a mapping. Pick Fly.io when you want the cheapest always-on hosted bill and will accept operating your own Postgres. Pick Railway when your workloads are bursty or your environments are many — per-second metering is a superpower for spiky usage and a tax on steady burn, so know which one you are. Pick Render when you want the closest thing to Heroku's managed simplicity and will pay the flat tiers for it. Pick the flat Hetzner box when you want control, generous egress, and indifference to growth within the box — and have the ops practice (or the platform layer) to carry the runbook. And when the team outgrows all of these, that is the exact seam BYOC and self-hosted PaaS exist to fill: Heroku-grade workflows on infrastructure whose bill stays in your name.

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.