Railway vs Render vs Fly.io vs a Flat Hetzner Box: The Cost Comparison Seenode's PaaS Framework Is Missing

In January 2026, Seenode published the best Heroku-alternatives guide of the year — not a feature list, but a decision framework built around billing models. Its punchline: stop comparing dashboards and match the billing model to your traffic pattern. Railway at $20-30 a month for variable traffic, Render at $57-plus for client work, Fly.io from near-zero to $50-plus for bursty multi-region apps.

It's a good framework. It's also missing a row. The moment your workload is always on and your traffic starts growing, the cheapest answer isn't any of the three — it's a flat box you rent by the month and fill to the brim. Here is the punchline first, with the full line-by-line math below.

The punchline first: one workload, four bills​

Take a typical small production SaaS that is always on: a web service (1 vCPU, 2 GB RAM), a background worker (1 vCPU, 1 GB RAM), a small managed Postgres, 10 GB of volumes, and 500 GB a month of outbound traffic. Priced from public rate cards:

And here is the part that matters more than any single number — what happens when traffic grows:

The Hetzner column doesn't move because there is nothing to meter: 20 TB of traffic is included with the box, and compute is a flat monthly fee, not a per-vCPU, per-GB-RAM, per-GB-egress meter. Every other column climbs with your success. That is the comparison Seenode's framework never runs — and for a team whose exit strategy is to stop renting, it's the only one that matters.

All hosted figures are estimates from public rate cards (January-September 2026), rounded and simplified; verify against current pricing before budgeting. The shape of the tradeoff moves much slower than the numbers.

What Seenode's framework gets right​

Seenode's guide, written by Durojaye Olusegun, makes one argument that reframes the whole Heroku-alternatives conversation: people compare features, but they should compare billing models. Dashboards, framework support, and CLIs are roughly fine everywhere now. What actually determines whether a platform feels good or terrible is whether its billing model matches your traffic pattern — because the wrong model turns every deploy into a question of what next month's invoice will look like.

The framework identifies three models that have crystallized since Heroku killed its free tier in November 2022:

• Fixed per-node tiers (Seenode, Render). A flat monthly rate for provisioned capacity. Predictable and simple, wasteful when your app idles. Best for steady traffic and teams that hate billing surprises.
• Usage-based metering (Railway, Fly.io). Per-minute compute, per-second CPU, per-GB storage and bandwidth. Efficient at low or variable usage, smooth scaling with spikes — and unpredictable if you don't watch the dashboards. Seenode's memorably bleak line: if that monitoring discipline doesn't describe you, this model can feel like a tax audit every month.
• Serverless (Vercel, Netlify). Pay per invocation. Great for static-first and spiky workloads, awkward for stateful backends with queues, WebSockets, and workers.

Its cost table for a 1 GB web service plus 1 GB of Postgres is the concrete anchor the genre usually lacks: Seenode $11 fixed, Fly.io $12-15 with self-managed Postgres, Railway $20-30 on Pro, Render $57-plus with point-in-time recovery and zero-downtime deploys. It also names the cliff nobody mentions — Fly.io looks cheap until you turn on managed Postgres, at which point the bill jumps to $43-50 and the "cheap" mental model quietly disappears — and four hidden costs: egress fees, Railway's credit ratchet, storage billed on stopped machines, and the backup story that is invisible until the day it is the only line item that matters.

All of this is correct and worth internalizing. But the framework's decision tree ends at "pick the cheapest hosted PaaS," and its budget ladder tops out with Render's enterprise tiers. Self-hosting gets one paragraph: fine under $50 a month on Hetzner with Coolify or Dokploy, but "downtime in this model is almost always your fault." That paragraph deserves to be a column in every table.

The fourth billing model: flat hardware​

Here is the Hetzner rate card that the framework never puts next to its PaaS numbers. On the cloud side, a CX33 virtual machine — 4 vCPU, 8 GB RAM — costs €8.49 a month; a CX43 with 8 vCPU and 16 GB is €15.99. On the dedicated side, an AX41 box — 6 cores, 12 threads, 64 GB of RAM, two 512 GB NVMe drives — runs about €57 a month, and an AX42 with a Ryzen 7 PRO, 64 GB of DDR5, and the same NVMe pair is about €77. Every one of them includes 20 TB of monthly traffic, with overage at roughly €1 per TB.

Now compare the metering surface. Railway bills $20 per vCPU-month, $10 per GB-RAM-month, about $0.05 per GB of egress, and per-GB volume storage — plus a $20 Pro seat whose included credit covers the first $20 of usage and then quietly becomes a floor. Render bills per provisioned service tier, per database tier, per GB of disk, and — since its April 2026 replan — a $25 Pro workspace fee plus $0.15 per GB of bandwidth beyond a 25 GB allowance. Fly.io bills per Machine-second, roughly $5 per GB of RAM-month, $0.02 per GB of egress in North America and Europe, and $0.15 per GB-month for volumes that keep billing even when the machine is stopped.

The flat box has none of these meters. There is no per-vCPU line, no per-GB-RAM line, no egress line until you cross 20 TB — forty times the 500 GB in our reference workload. Adding a second always-on service to a hosted PaaS adds a second line item; adding it to the flat box adds nothing until you run out of machine. For our reference workload, even the €8.49 cloud VM swallows it whole with room to spare, and the €57 dedicated box holds it roughly ten times over. That structural difference — meters versus a ceiling — is what the "which hosted PaaS" framing can't express, because it only compares meters against other meters.

Head-to-head: the line-by-line math​

Let's show the work for the reference workload: web (1 vCPU / 2 GB), worker (1 vCPU / 1 GB), small Postgres, 10 GB volumes, 500 GB egress.

Railway. Compute usage runs about 2 vCPU × $20 plus 3 GB × $10, roughly $70, with the database service adding on the order of $20 more. The $20 Pro subscription includes a $20 usage credit, so the metered remainder lands near $70-90. Egress adds 500 × $0.05 = $25. Volumes add about $1.50. Total: ~$115 a month, and the two lines that grow with you are compute and egress.

Render. Two Standard-tier services (web plus worker) at $25 each is $50. A production Postgres with point-in-time recovery sits near $20, the Pro workspace adds $25, and disk adds a few dollars.

The painful line is bandwidth: 475 GB beyond the included 25 GB at $0.15 per GB is about $71. Total: ~$170 a month — and note that bandwidth alone now exceeds the entire compute bill.

Fly.io. Two shared-CPU Machines with 3 GB of RAM between them cost on the order of $20 a month running continuously. Managed Postgres is the step function Seenode warned about: it roughly doubles the bill versus self-managed, landing compute-plus-database near $50. Egress is the friendliest of the three hosted options at 500 × $0.02 = $10. Volumes add about $1.50. Total: ~$60 a month.

Hetzner flat. The workload fits on a €8.49 cloud VM with headroom, or on a €57 dedicated box at roughly a tenth of its capacity. Egress is 2.5% of the included 20 TB, so the bandwidth line is zero. Total: €8.49-57 (~$10-62), and it does not move when traffic doubles.

Now the sensitivity sweep, because the ranking at one traffic point is trivia and the ranking across a range is a decision:

• At 100 GB egress, hosted totals fall to roughly $95 / $110 / $52. The flat box still wins on price against all three at the cloud-VM size — the dedicated box breaks even against Railway here and beats Render outright.
• At 500 GB, the table above: bandwidth starts to dominate Render's bill, Railway climbs steadily, Fly.io barely moves.
• At 2 TB, Railway approaches $190, Render approaches $400 — bandwidth alone is ~$300 — while Fly.io stays under $100 thanks to $0.02 egress. The flat box is still €8.49-57. Hetzner's included 20 TB means this sweep ends at a tenth of the allowance.

Three crossover lessons fall out. First, for always-on workloads, the flat box isn't the expensive "eventually" option — it's cheaper than every hosted column at every traffic level shown, because hosted platforms charge you for being on while the box charges you for existing. Second, each hosted platform has a different tripwire: Render's is bandwidth ($0.15 per GB is the steepest meter in this comparison), Railway's is the joint climb of compute plus egress, Fly.io's is managed Postgres (a step function, not a slope). Third, Fly.io is genuinely the cheapest hosted answer across this whole range — which is exactly why the honest version of this post needs the next section.

When hosted still wins (the honest counter)​

A cost table that only shows meters is as incomplete as a framework that only shows hosted platforms. Flat hardware has a price too — it's just denominated in hours and risk instead of dollars, and Seenode is right that downtime on a box you own is almost always your fault. Here is when each hosted option still wins, stated as plainly as the math above:

• Bursty or scale-to-zero workloads → Fly.io. If your app idles 20 hours a day, per-second billing for Machines that stop when idle beats a box that bills while asleep. The flat box wins on always-on; it loses on mostly-off.
• Variable traffic with Heroku-like DX → Railway. If your team ships from git push and nobody wants to think about infrastructure, Railway's workflow plus usage billing is the closest thing to the old Heroku magic — as long as someone watches the usage dashboard so the credit ratchet doesn't surprise you.
• Client work and enterprise needs → Render. When PITR, zero-downtime deploys, SSO, SOC 2, and a support contract are non-negotiable, Render's premium is trivial next to the cost of one client-facing outage — or one failed vendor-security review that a self-hosted box can't pass.
• Multi-region latency → Fly.io. If your users span continents and latency matters, Fly.io's multi-region Machines are a first-class primitive. Reproducing that on flat hardware means boxes in multiple regions plus your own anycast and failover story — a different project entirely.

And the flat box's own hidden costs deserve the same itemized honesty Seenode gives hosted platforms: you own backups and point-in-time recovery (or you build them), you own OS patching and incident response at 3 AM, you own the migration when the box fills, and you have no compliance badge to show a procurement team.

Price the ops hours for your team explicitly — at even a few hours a month of senior-engineer time, the hosted premium can be the rational buy. The box wins the invoice comparison; whether it wins the total-cost comparison depends on whose pager goes off.

The fifth question for the framework​

Seenode's framework asks four questions: can you tolerate variable billing, what's your budget ceiling, do you need enterprise features, is global distribution critical? It needs a fifth:

Is your exit strategy to stop renting — or to keep renting efficiently?

If the answer is "keep renting," the framework as written is all you need: match the billing model to your traffic shape, mind the tripwires, re-check the rate cards yearly. But if the answer is "stop renting" — if every always-on service you add is a line item you intend to eventually delete — then run this post's comparison alongside Seenode's, and re-run it on two triggers: when monthly egress crosses ~500 GB (where Render's bandwidth meter starts dominating), and every time you add another always-on service (each one is a new hosted line item and approximately zero marginal cost on a box with headroom).

The deeper point is the one Seenode itself makes: billing model matters more than features. Flat hardware isn't a different feature set — it's a fourth billing model, with the meters removed instead of repriced. Any framework that compares three ways of metering without asking whether you need a meter at all will keep recommending the cheapest meter. Sometimes that's right. But for the always-on workload on owned hardware's home turf, the cheapest meter costs double to quadruple the flat fee — and the gap widens with every gigabyte.

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.