Railway vs Render vs Fly.io for Solo Developers in 2026: The Hidden-Cost Anatomy

Every solo-developer hosting comparison in 2026 converges on the same one-liner: Fly.io is cheapest when your app scales to zero, Render wins on predictable flat pricing, Railway wins on developer experience. That verdict is not wrong. It is just priced on the headline numbers — the compute line — while the actual bill is decided three lines down, in bandwidth, IPv4 addresses, and volumes.

This post prices two concrete side projects line by line on all three platforms: one always-on app and one bursty app that idles 90% of the month. Same stack each time — a small web service plus Postgres, a custom domain, a 5 GB volume, and realistic egress. Then it prices the fourth option nobody's pricing page mentions: one flat-rate Hetzner box.

The bill first: two apps, three platforms, one table​

Here is where the math below lands. All figures are per month, October 2026 list prices, app plus managed-or-self-hosted Postgres plus volume plus egress plus domain.

Two surprises before we open the ledger. First, the bursty ranking is not "Fly.io, then everyone else roughly tied": Railway's bursty bill can exceed its always-on rival Render because the database never sleeps. Second, the Hetzner row undercuts every always-on column right now — not at scale, not with ten services, with one app and one database. The rest of this post shows exactly which line items produce those totals, and at what traffic or storage level each ranking flips.

The rate card that actually matters​

Pricing pages optimize for the compute line. The bill optimizes for everything else. Here is the comparable unit-price card, with each platform's billing gotcha attached.

Sources: Railway's 2026 pricing explainer and Prisma's October 2026 platform survey for Railway and Fly.io unit prices; Render's per-service price list plus the documented 2026 bandwidth replan (100 GB included, $0.15/GB overage) for Render; Fly.io's pricing docs for egress and IPv4; Hetzner's 2026 cloud price list for the CX22 at roughly €4.49 with 20 TB of traffic.

Read the "gotcha" column, not the price column. Railway meters everything, including an idle service you forgot — a forgotten 1 vCPU/1 GB service costs roughly $30/mo until you enable Serverless sleep or delete it. Render's flat instance is honest, but its overage lines ($0.15/GB bandwidth, $0.25/GB disk) are the steepest here. Fly.io's compute looks nearly free until you add the $38 managed-Postgres floor most newcomers click past — solo devs on Fly run Postgres on a Machine or use SQLite, and the bill below assumes exactly that.

Worked bill #1: the always-on side project​

The spec: a web service at 0.5 vCPU/512 MB running 24/7, a small Postgres, 50 GB of monthly egress, a 5 GB volume, one custom domain. This is the median side project — a SaaS-in-progress, a bot with a dashboard, a self-hosted tool you actually use.

Railway: ~$33/mo. Web compute (0.5 × $20 + 0.5 × $10) is $15. Postgres at the same size is another $15. The 5 GB volume adds $0.75, 50 GB of egress adds $2.50.

Total metered usage is ~$33.25 against the $5 Hobby plan that includes $5 of usage, so you pay the full ~$33. Every line is fair at unit level; there are just five of them, all running at 100% duty cycle.

Render: ~$14/mo. Starter web service $7, Basic-256MB Postgres $6, 5 GB disk $1.25, one domain included, and 50 GB of egress falls inside the 100 GB included allowance: $0. Total $14.25. This is the flattest bill in the comparison — nothing here can surprise you next month except growth.

Fly.io: ~$9–11/mo. A shared-cpu-1x/512 MB web Machine always-on is ~$3.57. Self-managed Postgres on an identical Machine is another ~$3.57, plus the 5 GB volume at $0.75. Fifty GB of NA/EU egress at $0.02/GB is $1.00. Shared IPv4 is $0, which keeps the total at ~$8.89 — call it $9.

Add a dedicated IPv4 at $2/mo (needed for apex records without CNAME support or non-HTTP traffic) and it is ~$11. Either way, cheapest of the three.

Hetzner CX22: ~$5/mo. Roughly €4.49 for 2 vCPU, 4 GB RAM, 40 GB NVMe, and 20 TB of included traffic — about $5.25 at current rates. Postgres runs on the box, the volume is local NVMe, 50 GB of egress is a rounding error against 20 TB. The bill is one line. The catch is also one line: you are the database administrator, the backup cron job, and the 3 a.m. pager.

Always-on ranking: Hetzner ($5) beats Fly.io ($9–11), which beats Render ($14), which beats Railway ($33). The spread between first and last PaaS is nearly 4x on identical workloads — and compute-unit price alone would never have told you that, because Railway's compute is only expensive in the way that matters here: it never stops.

Worked bill #2: the bursty side project​

Same stack, different duty cycle: awake roughly 10% of the month (evenings, weekends, the occasional demo), serving 10 GB of egress. The staging environment, the hackathon project, the client demo that gets opened twice a week. This is the workload the "Fly.io is cheapest when it scales to zero" verdict is about — so let's check whether the rest of the bill agrees.

Fly.io: ~$2–5/mo. Both Machines autostop when idle, so ~73 awake hours cost about $0.72 in compute. The 5 GB volume cannot sleep — provisioned storage bills at $0.75 regardless. Ten GB of egress is $0.20. With shared IPv4, the total is ~$1.67: call it $2.

Two honest caveats move it toward $5: a dedicated IPv4 ($2) more than doubles this bill, and autostopping a database is operationally brave — keep Postgres warm and you add ~$3.20 back. Either configuration is still the cheapest PaaS answer here.

Render: ~$14/mo. Unchanged from bill #1, to the cent. Paid Render instances do not sleep; the Starter web service is $7 awake or idle, Postgres is $6, the disk is $1.25, egress is inside the allowance. Render sells you predictability, and predictability cuts both ways: your bursty app costs exactly as much as your busy one. (The free tier does sleep, but at 0.1 CPU and with spin-down latency it is a demo tier, not a production answer.)

Railway: ~$18 with Serverless sleep, ~$33 without. Here is the trap the verdict tables miss. Enable Serverless and the web service sleeps: 10% of $15 is $1.50. But volume-backed Postgres does not reliably sleep — Railway's own docs stay quiet on whether a database with a volume can nap, and operators report it stays warm. So the database bills the full $15, the volume $0.75, egress (10 GB × $0.05) $0.50: ~$17.75 against Hobby, or ~$18 out of pocket.

And if you never enabled Serverless — it is opt-in, per service, and any polling loop or uptime pinger defeats it silently — the web service bills the full $15 and you are back at ~$33, paying always-on money for a 10%-awake app.

Bursty ranking: Fly.io ($2–5) beats Render ($14), which beats Railway ($18–33) — with Hetzner ($5) sitting flat in the middle, indifferent to your duty cycle. The database is the quiet decider: on every platform, the thing that cannot sleep sets the floor, and Railway's metered database sets the highest floor of all.

The hidden-cost anatomy: bandwidth, IPv4, volumes​

The two bills above used polite inputs: 50 and 10 GB of egress, 5 GB of storage, one domain. Real side projects outgrow polite inputs. Here is each hidden line item with the crossover number where it flips a ranking.

Bandwidth: the ranking-flipper. The overage spread is 7.5x: $0.15/GB on Render past 100 GB, $0.05/GB on Railway from byte one, $0.02/GB on Fly.io from byte one. At 50 GB/mo the difference is noise ($0 vs $2.50 vs $1). At 500 GB/mo it is the bill: Render adds $60 in overage, Railway $25, Fly.io $10. The crossover that matters: a Render app serving ~150 GB/mo pays ~$7.50 in overage and is still cheaper than Railway's metered compute — but past ~300 GB/mo, Render's bandwidth line alone exceeds Fly.io's entire always-on stack. If your side project serves images, video, downloads, or an API with chunky responses, price egress before you price compute.

Railway has a second bandwidth trap worth one sentence: connecting to your own database over its public URL bills egress per gigabyte — the private *.railway.internal hostname is free, and using it is not optional at scale.

IPv4: the bill-doubler on small apps. Fly.io's $2/mo dedicated IPv4 is 20% of the always-on bill and 100%+ of the bursty bill. Most solo HTTPS apps never need it — shared IPv4 plus Fly's free TLS termination is fine — but the moment you need an apex record your DNS host can't CNAME, raw TCP, or a stable egress IP for an allowlist, it lands as a flat tax that hits the smallest bills hardest. Railway and Render bundle ingress addressing into the platform, so this line simply doesn't exist for them.

Rule of thumb: if your Fly bill is under $5, a dedicated IP is the single largest line item on it. Check whether you actually need one before adding it.

Volumes: the slow ratchet. Render's $0.25/GB-month vs $0.15 on Railway and Fly.io looks trivial at 5 GB ($1.25 vs $0.75 — fifty cents). At 100 GB of user uploads or database growth, it's $25 vs $15: a $10/mo gap that compounds every month your app succeeds. Worse, volume pricing is the line item most coupled to success — databases only grow — and the hardest to migrate away from, because moving 100 GB of stateful data between platforms is a weekend you will not get back.

All three platforms bill provisioned-not-used storage, so over-provisioning "just in case" is a standing donation. Size volumes to measured usage plus one growth step, not to your ambitions.

The two floors nobody advertises. First, managed Postgres: Fly.io's Managed Postgres starts at $38/mo plus $0.28/GB storage — more than triple Render's entire always-on stack. It is a fine product and a catastrophic default for a side project; the solo-dev move on Fly is a self-managed Postgres Machine (~$4 all-in) or SQLite. Second, Render's satellite fees: $0.25/mo per extra custom domain and $5 per 1,000 build minutes. Neither decides a comparison alone, but a developer with six toy domains and a rebuild-happy monorepo will find them.

The Hetzner crossover​

Let's make the fourth column explicit, because "just get a VPS" is usually asserted, not priced. A Hetzner CX22 — 2 shared vCPU, 4 GB RAM, 40 GB NVMe, 20 TB of traffic — lists at roughly €4.49/mo after the April 2026 adjustment, about $5.25. Overage traffic is €1/TB, which reads as a typo next to PaaS bandwidth: the 500 GB/mo that costs Render $60 in overage is 2.5% of the CX22's included allowance.

The crossover point is not a scale threshold. It is workload count one. A single always-on app plus Postgres costs ~$5 on the box against ~$9–33 on the metered platforms — the box wins on day one, with 20 TB of headroom and a whole second vCPU still idle. The bursty case is the one place metered pricing fights back: a sleeping Fly app at ~$2/mo undercuts the always-on box, until a dedicated IP, a second app, or real egress erases the gap.

The honest price of the box is not €4.49. It is €4.49 plus operations: you install Postgres, you configure backups and test restores, you patch the OS, you are the on-call rotation. For one developer with one side project, that is maybe an hour a month once it's set up — plus the tail risk of learning backup verification the hard way. The platforms sell freedom from exactly that. So the real crossover question is not "when is Hetzner cheaper" (answer: almost immediately, in dollars) but "when is your time worth more than the spread" — and for a second always-on app, when the marginal PaaS cost is another $9–33/mo against $0 on the box you already rent, the box usually wins that argument too.

This is also where a self-hosted PaaS earns its place: it keeps the flat-rate hardware economics while taking back the git-push deploys, TLS, and sleep-when-idle behavior the metered platforms bundle. Pay the box rate, keep the workflow.

Which one for your side project​

Three rules, keyed to the shape of your app rather than anyone's verdict table:

1. Bursty or experimental (sleeps most of the month): Fly.io. Autostop is built in, not opt-in, and the idle floor is a $0.15/GB volume plus pennies of egress. Stay on shared IPv4, self-manage Postgres or use SQLite, and watch nothing — there is almost nothing to watch. Expected bill: $2–5/mo.
2. Always-on with modest traffic (under ~100 GB egress): Render. The $14 stack is flat, legible, and includes the bandwidth most side projects never exceed. The moment egress trends past ~200 GB/mo, re-run the bandwidth math — that is the line that evicts Render from this slot.
3. Always-on with spiky compute, or previews per PR: Railway — with Serverless sleep enabled on day one. Per-second metering is genuinely the cheapest shape for workloads that burst and rest, but only if things actually rest. Audit for always-warm services quarterly; each forgotten one is ~$30/mo. And remember the database floor: metered Postgres sets a ~$15/mo minimum your bursty app cannot sleep below.

And the fourth rule, the one the pricing pages never print: when you have two always-on projects, price one Hetzner box. At ~$5/mo flat with 20 TB of traffic, it undercuts every column in both tables above the sleeping-Fly edge case — the spread pays for a managed-backup sidecar and still leaves change. The premium you pay the metered platforms is real operational value (no patching, no pager), so spend it deliberately: on the app whose uptime matters, not by default on all of them.

Running more than one side project? Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own, with the flat-rate hardware economics above and the git-push workflow intact. Star the repo on GitHub or deploy your first app today.