Railway vs Render vs Fly.io: The Cheapest One Changes as You Grow

Every comparison of these three declares a winner. That’s the mistake — because they don’t just charge different amounts, they charge for different things, and each says so on its own pricing page:

• Railway: “Pay only for what your app uses, by the second.” Metered consumption. You never pick an instance size.
• Render: “Predictable pricing that scales with you.” Fixed instance tiers. You pick a box and pay for it.
• Fly.io: “Plans get complicated, so we just charge based on usage.” Provisioned micro-VMs, no plan tiers at all.

Price the same app across all three and the ranking turns on a question most comparisons never ask: do you need a dedicated CPU core, or will a shared one do? Because only one of these three sells you the cheap shared option, and it changes the answer by a factor of three.

The three rate cards

Railway meters actual consumption per second:

Plans are billed as a minimum usage commitment that includes matching credit: Free ($0, capped at 1 vCPU / 0.5 GB per service), Hobby $5, Pro $20 per workspace — seats unlimited and included, not per seat.

Render sells fixed instance tiers, prorated by the second:

On top of compute sits a workspace plan: Hobby $0 (5 GB bandwidth included), Pro $25/mo (25 GB), Scale $499/mo (1 TB). Bandwidth beyond the allowance costs $0.15/GB.

Fly.io bills provisioned Machines with no plan tier at all — and crucially, sells both shared and dedicated CPU:

Note the region selector in that screenshot — those are Amsterdam prices, and Fly applies regional markups, so price your own region.

Egress is $0.02/GB in North America and Europe, $0.04 in Asia-Pacific and South America, and $0.12 in Africa and India. Render’s $0.15/GB overage is 3× Railway’s and 7.5× Fly’s NA/EU rate.

The same app at three sizes

Arithmetic on the rates above, with assumptions stated so you can substitute your own.

Small always-on app — under a gigabyte, 5 GB of traffic:

Small production app — 2 GB RAM, 50 GB of traffic. Here the CPU question splits the field:

Growing app — 4 GB RAM, 200 GB of traffic:

Two findings, and they point different ways.

On shared CPU, Fly is not close — it’s three to four times cheaper at every size. Neither Railway nor Render sells an equivalent: Railway’s rate is a flat $20 per vCPU whether you need a full core or a tenth of one, and Render’s cheapest 2 GB option is a dedicated core at $25. If your app is a typical small web service that spends most of its life waiting on I/O, shared CPU is almost certainly enough, and this is the cheapest column on the page by a wide margin.

On dedicated CPU, the ranking inverts as you grow. Render wins the middle band at $31.75, then becomes the most expensive at the top ($114.25) because its $0.15/GB bandwidth compounds. Railway sits in between, and Fly’s performance tiers beat both at the top.

The variable that decides Railway

Those Railway figures assume a full vCPU held continuously. Almost no small app does that.

Railway is the only one of the three that bills what you actually consume, so the same service averaging 40% utilisation costs $30.50 rather than $42.50 — enough to take the dedicated-CPU middle band outright. On Render and Fly, the gap between what you provisioned and what you used is money already spent.

So: Render if your load is flat, Railway if it’s spiky, Fly if shared CPU will do. Only the metering tells you which you have.

The operational costs that outrun the compute

Free tiers are not equivalent, and one expires

Render’s free tier looks the most generous and carries the sharpest edge. Free web services get 512 MB and 750 instance hours per workspace per month, and Render “spins down a Free web service that goes 15 minutes without receiving any inbound traffic.” Waking it takes about a minute, during which visitors see a loading page. That is not a cold start you can put in front of users.

Worse, free Render Postgres databases expire 30 days after creation, with a 14-day grace period before deletion. They’re capped at 1 GB with no backups and no connection pooling. A database that deletes itself a month in is the most common way a side project on Render dies quietly.

Railway’s free plan gives $1 of monthly credit after a 30-day trial with $5, capped at 1 vCPU and 0.5 GB per service. Fly has no free tier as such — but shared-cpu-1x at $1.94/month is close enough that the distinction rarely matters.

Every sleep mechanism fails differently

• Render spins down after 15 minutes with no inbound traffic; ~1 minute to wake.
• Railway sleeps after 10 minutes with no outbound packets. Its docs warn that “the first request sent to a slept service may return a 502 Bad Gateway response.”
• Fly stops Machines via auto_stop_machines and you don’t pay CPU or RAM while stopped — though a stopped Machine still costs about $0.15 per GB of root filesystem per 30 days.

That last one matters for background workers: Fly’s autostart is driven by Fly Proxy responding to HTTP, so a worker with no inbound traffic has nothing to wake it. Railway’s trigger includes private-network traffic from a sibling service, which fits the worker pattern better.

And a WebSocket service defeats all three — a heartbeat means packets never stop, no idle timer fires, and you pay continuously everywhere.

Managed Postgres

Render is the only one of the three with a published tier list: Basic-256mb $6/mo, Basic-1gb $19, Pro-4gb $55. Expandable storage runs $0.30/GB and SSDs $0.25/GB per month.

Catch the oddity before you pick: Basic-4gb costs $75/month while Pro-4gb costs $55 — same memory, $20 less — because the tiers differ on connection limits and features rather than sitting on one ladder. The plan whose name sounds smaller is not always cheaper.

On Railway and Fly you run the database yourself on metered or provisioned resources: cheaper at small sizes, more work.

Which one, by situation

Choose Railway if your traffic is spiky or you don’t yet know your load. Metering means you never buy headroom, and for an app averaging well under its peak it’s the cheapest dedicated-CPU option in the middle band. Best dashboard of the three and the shortest path from repo to running service. The constraint is four regions — US West, US East, EU West and Singapore.

Check Railway pricing → · Read our Railway review

Choose Render if your load is flat and you want a predictable invoice. $25/month for a 2 GB Standard instance is the easiest number to budget here, and the Hobby workspace is free. Watch the bandwidth — 5 GB included, then $0.15/GB, which is where predictable stops being predictable.

Read our Render review

Choose Fly.io if you’re cost-sensitive or geography matters. Its shared-CPU tiers undercut both rivals by three to four times, and it runs 30+ regions against Railway’s four. The trade: you size your own Machines, shared CPU is genuinely shared, and its homepage now leads with agent workloads rather than app deployment.

Read our Fly.io review

Choose none of them if the app is simply always on and predictable. All three charge a premium for elasticity you won’t use — the conclusion we also reached in Railway vs a VPS for n8n, and the reason Coolify on a cheap VPS keeps winning on raw cost. For the two-way detail, see Railway vs Fly.io.

How we picked

Every rate above is from the vendor’s own pricing page or documentation, read in August 2026, and each figure quoted appears in the screenshots above: Railway’s plan cards and per-second rates, Render’s workspace plans, instance table and $0.15/GB bandwidth overage, and Fly.io’s Machine table at Amsterdam pricing. Fly’s own region selector is visible in that screenshot — regional markups apply, so price your region.

Free-tier behaviour — Render’s 15-minute spin-down and ~1-minute wake, its 30-day Postgres expiry, Railway’s 10-minute sleep and documented 502 on first request, Fly’s autostop mechanics — is quoted from each vendor’s documentation rather than third-party summaries. That distinction earned its keep: several comparison sites still list Railway’s Pro plan as per-seat when it is per-workspace, and one widely-cited page miscalculated Railway’s vCPU rate by two orders of magnitude.

What we did not do: we have not deployed the same application to all three and reconciled three months of invoices. These are arithmetic on published rates under stated assumptions, not measured bills. Two assumptions move the answer most — your app’s average consumption against its peak, which decides whether Railway’s metering beats fixed tiers, and whether shared CPU is adequate for your workload, which decides whether Fly’s cheapest column is available to you at all. Neither is knowable from outside your app.

Finding out costs an afternoon: deploy to Railway’s 30-day trial ($5 credits, no card), watch the metered usage graph for a week to read your real average consumption, then price the equivalent Render instance and Fly Machine against that number. We also haven’t measured cold-start latency ourselves — Render publishes “about a minute,” Fly says suspended Machines resume faster than stopped ones without giving a figure, and we’d rather cite no number than someone else’s.

The Railway link above is an affiliate link. Render and Fly.io do not run programmes we participate in — worth knowing when you notice that Fly wins most of the price bands above on our own numbers.

FAQ

Which is cheapest: Railway, Render or Fly.io?

Fly.io, if shared CPU suits your app — its shared-cpu tiers run three to four times cheaper than anything Railway or Render offer, from $1.94/month. On dedicated CPU it’s closer and the ranking inverts with size: Render wins a 2 GB app at $31.75, while Fly wins a 4 GB one at $74.35 against Render’s $114.25.

Does Render’s free tier sleep?

Yes. Render spins down a free web service after 15 minutes without inbound traffic, and waking it takes about a minute with a loading page shown to visitors. Treat it as a demo environment, not a hosting plan.

Do free Render databases expire?

Yes. Free Render Postgres databases expire 30 days after creation, with a 14-day grace period before deletion, and are limited to 1 GB with no backups and no connection pooling.

Is Railway more expensive than Render?

At full continuous utilisation, yes — $42.50 against $31.75 for a 2 GB app with 50 GB of traffic. But Railway bills actual consumption, so the same app averaging 40% of its peak costs about $30.50 and comes in cheaper. Flat load favours Render; spiky load favours Railway.

Which has the most regions?

Fly.io, with 30+ against Railway’s four (US West, US East, EU West, Singapore). If your users are in Australia, India, Brazil or Africa, no amount of dashboard quality compensates for the distance.

What’s the catch with Render’s bandwidth?

The Hobby workspace includes just 5 GB a month, then charges $0.15/GB — three times Railway’s rate and seven and a half times Fly’s NA/EU rate. It’s why Render goes from cheapest in the middle band to most expensive at 200 GB.

Which is best for a background worker?

Railway or Render. Fly’s autostart is driven by Fly Proxy responding to HTTP requests, so a worker with no inbound traffic has nothing to wake it. Railway wakes on private-network traffic from a sibling service, which fits the pattern better.