Railway vs Render vs Fly.io on July 19, 2026: Same Stack, Three Bills, and Where the Meter Moves First

Techsy's July 19, 2026 audit re-checked every price, plan name, and region count for Railway, Render, and Fly.io on the same day — the first same-date comparison since all three vendors shuffled pricing in early 2026. Run the same Node.js + Postgres workload through each audit and the headline cheapest flips as soon as you count the two lines pricing pages hide: per-service multiplication and egress.

Here is the answer up front for an identical, always-on stack — one Node API (512 MB RAM, 0.5 vCPU) plus one Postgres (1 GB RAM, 1 vCPU), 20 GB of persistent volume, 730 hours, four egress levels — recomputed from the July 19 numbers:

A single, tiny, idle service is the only shape where Railway's credit pool looks cheapest. Add a real database and count bandwidth the way each platform actually invoices, and the cheapest-to-most-expensive gap moves twice — first on per-service multiplication, then on egress. The rest of this post shows every line's math, why the July 19 date matters, and what the same workload collapses to when the bandwidth is not a line item at all.

Note on the idle row: Railway's compute meter is linear, not flat. A 1.5 GB + 1.5 vCPU always-on footprint is $45/month before credits — the credit pool ($5 Hobby or $20 Pro) does not make it cheaper, it just sets a floor you pay even if you use less. The table above uses the real metered total (credits absorbed), not " $5" . Section 3 unpacks this line by line.

What Techsy Re-Checked on July 19 and Why Same-Date Matters​

Techsy's comparison page — originally published March 17 and last modified July 19, 2026 — carries a detail most pricing roundups skip: the modified date. On July 19 the authors re-verified:

• Plan names. Railway still advertises Hobby ($5/month with $5 included usage) and Pro ($20/month with $20 included usage) after removing its free tier in 2023 — new accounts get a one-time $5 trial credit, then must pick a paid plan. Fly.io's old $5 free allowance is gone for new organizations — new orgs get a short trial (2 VM-hours or 7 days) and then need a card on file. Only Render retains an ongoing free tier, and it still cold-starts.
• Render's April 23, 2026 workspace restructure. Render introduced new workspace plans (Hobby, Pro, Scale, Enterprise) that remove per-seat billing in favor of a flat workspace subscription. Compute pricing per service did not change, but bandwidth and custom domains moved to workspace-level metering with a new included baseline and overage at roughly $0.15/GB after August 1. Every legacy workspace auto-migrates by August 1. A pre-April comparison table is therefore wrong for bandwidth.
• Railway's March 2026 experimental HA Postgres. Railway launched an opt-in HA Postgres with automatic failover, but the docs still warn it is experimental and not yet production-ready. The default remains a containerized Postgres with daily backups but no PITR, no read replica, and no managed failover. Techsy correctly flags this as "not managed Postgres" for anyone comparing against Render's managed Postgres with PITR.

Why this matters: between March and July every vendor changed at least one name or included amount. Comparing a March screenshot of Railway Hobby against a June screenshot of Render workspaces and a January Fly.io price silently miscounts bandwidth and database resilience. A same-date audit is the only honest baseline — and July 19 is the first one after Railway's HA Postgres and Render's workspace cutover both landed.

How Each Meter Actually Works​

Railway: a subscription that turns into credits, then per-minute meters​

Railway's 2026 model is a flat monthly subscription that converts 1:1 into usage credits, plus metered overage billed per minute (measured per second, rounded up):

• Hobby — $5/month: includes $5 in usage credits for the workspace total. You pay $5 even if you use $2. If you use $12, you pay $12.
• Pro — $20/seat/month: includes $20 in credits per seat, higher per-service caps, and team features. Same burn logic, higher floor.

Once credits are exhausted:

• RAM: $10 / GB / month
• vCPU: $20 / vCPU / month
• Persistent volume: $0.15 / GB / month
• Network egress: $0.05 / GB (ingress free; private networking between services is free for transfer)
• Build time and ephemeral disk: metered into the same compute pool

The critical detail: one workspace, one credit pool. Two services share one $5 Hobby pool. That is why every "Railway is $5" screenshot shows a singleton.

Render: flat per-service compute plus a workspace fee​

Render's new model (post-April 23) is two layers:

• Workspace fee: Hobby $0 (750 hours, sleeps, limited bandwidth and custom domains), Pro and above are flat per-workspace subscriptions that remove per-seat billing and raise included bandwidth and platform limits.
• Per-service compute: Web service Starter $7/month (512 MB RAM, 0.5 CPU), Standard $25/month (2 GB, 1 CPU), and similar steps for background workers and cron jobs. Each service you add bills its own flat. Background workers and cron jobs are not sharing one bucket — they each get a line.
• Managed Postgres: Starter $7/month (1 GB RAM, no HA), Standard $29/month with more storage, PITR, and higher connection limits. Unlike Railway's container DB, Render's Postgres is managed — backups, PITR, and failover are platform-owned.
• Volume: 1 GB included per service? Actually Render volumes are networked persistent disks billed separately; for small apps the included ephemeral disk is free and persistent storage is a line item only when attached.
• Bandwidth: Included amount per workspace (100 GB on paid workspaces in Techsy's July table), then $0.15/GB overage after August 1 — down from the earlier $0.30/GB.

Predictability is Render's pitch: the per-service flat makes forecasting easy, but it also multiplies fast. Two services double the flat; three triple it.

Fly.io: no base fee, many separate meters billed per second​

Fly.io has no monthly plan to buy. You pay for what you run, by the second:

• Machines (VMs): shared-cpu-1x with 256 MB is ~$1.94/month region-dependent if left on 730 hours; 512 MB ~$3.88; 1 GB ~$5.70–$7.70 depending on CPU. There is no sleep — if the Machine is running, it bills.
• Volume: $0.15 / GB / month, same sticker as Railway.
• Egress: tiered by region — $0.02/GB in North America and Europe, $0.04/GB in Asia-Pacific/South America, $0.12/GB in parts of Africa.
• IPv4: app-scoped dedicated IPv4 at $3.60/month per IP since January 1, 2026; IPv6 is free.
• Stopped-machine rootfs: $0.15/GB per 30 days for the image kept warm while a Machine is stopped.
• Inter-region private networking and volume snapshots: both started metering in early 2026 — cross-region WireGuard traffic now bills at Machine rates, snapshots bill per GB/month.

The per-second shape is genuinely cheapest for spiky or part-time workloads. For always-on apps, the headline compute savings survive, but the receipt is long — each primitive gets its own line.

The Worked Recompute: One Node Service + Postgres, Line by Line​

Reference stack — chosen to be boring, not exotic:

• App: Node.js API, 512 MB RAM, 0.5 vCPU, always-on (730 hours)
• Database: Postgres, 1 GB RAM, 1 vCPU, always-on, 20 GB persistent volume (10 GB app + 10 GB DB is the smallest durable Postgres footprint)
• Egress: four levels — 10 GB (idle/internal), 50 GB (baseline small SaaS), 200 GB (heavy), 500 GB (media/image-heavy)
• Region: US/EU (so Fly.io egress at $0.02/GB)

Baseline (50 GB egress) — the number you actually pay in month one​

Two observations fall out immediately:

1. Railway's credit pool does not rescue a DB-backed app. $45 in compute before volume and egress already dwarfs a $5 or $20 credit pool. The pool helps a singleton side project; it is noise against a full stack.
2. Render's flat per-service pricing wins at idle/low egress. $7 + $7 is cheaper than metering 1.5 GB RAM + 1.5 vCPU by the minute. That gap is why Render reads as "most expensive in absolute terms but most predictable" in Techsy's FAQ — it is most expensive only when you multiply services, not at this two-service baseline.
3. Fly.io's compute still edges out Railway, but volumes cancel half the saving. The API+DB VMs at ~$11.58 undercut Railway's $45, but $3 in volumes and the need for a $3.60 IPv4 (if you need a dedicated v4) narrow the win.

Sensitivity: double the egress​

Hold the stack fixed and move egress from 50 GB to 200 GB:

• Railway: +150 GB × $0.05 = +$7.50 → $58.00
• Render: 200 GB blows past 100 GB included → +100 GB × $0.15 = +$15.00 → $29.00 (Hobby) / $48.00 (Pro workspace)
• Fly.io: +150 GB × $0.02 = +$3.00 → $18.58

At 200 GB the cheapest-to-most-expensive order is Fly.io ~$19, Render ~$29, Railway ~$58. At 500 GB, Render's overage catches Railway ($74 vs $73) and Fly.io is still ~$23. Bandwidth is the lever that moves first once services are counted honestly — not compute.

Where the Gap Moves First​

Per-service multiplication​

All three platforms bill more when you add a worker, a cron, or a second API:

• Railway: linear — another 512 MB + 0.5 vCPU adds $15 whether it is a worker, a queue, or a second API. Two services sharing one credit pool is where Hobby stops looking cheap.
• Render: stepwise flat — a background worker on Starter is another $7. Add a cron and you are at $21 in compute before Postgres. Predictable, but not sublinear.
• Fly.io: one more Machine of the same size is one more per-second meter — roughly $3.88 for another 512 MB worker. There is no sharing.

A team that starts with "just an API" and later adds a worker for queues or cron pays the second-service tax on every platform. The question is slope: Railway slopes steepest because RAM+vCPU price is high per GB, Render slopes in $7 steps, Fly slopes in ~$3.88 steps.

Egress sensitivity​

Recompute the same stack at each egress level (Render Pro workspace at ~$19 included for a fair non-cold-start comparison, Fly.io NA/EU):

Three patterns:

• Railway is flat-ish across egress because compute dominates — bandwidth is only $0.05/GB but $45 of compute dwarfs it until you hit media scale.
• Render is flat until 100 GB then steps hard at $0.15/GB — batch your images through a CDN and the overage line is the one to watch.
• Fly.io hardly moves in NA/EU because $0.02/GB is the lowest metered egress of the three hosted PaaS — but route the same 500 GB through Fly's Africa egress at $0.12/GB and Fly's total jumps to ~$73, matching Railway.

Region choice is a hidden egress multiplier Fly.io's pricing page does disclose — but only if you read the footnotes.

What comparisons still hand-wave​

• Database resilience: Railway's default Postgres is a container with daily backups; PITR, read replicas, and managed failover are not included. Railway's March 2026 HA Postgres adds failover but is still marked experimental and not recommended for production by Railway itself. Render's managed Postgres includes PITR on paid tiers. Fly Postgres is explicitly "not managed" — Fly will tell you to bring Neon, Supabase, or self-hosted recovery. For production data, comparing only $7 vs $7 for the DB misses the managed-ness gap entirely.
• Volume snapshots and cross-region mesh: Fly's new meters for snapshot storage and inter-region private networking mean a multi-region deploy with daily snapshots has two line items Railway and Render bundle differently. Techsy's "pricing table above for four traffic tiers" deliberately kept single-region to avoid speculative multi-region math — the same discipline this recompute follows.
• Cold starts: Render's Hobby workspace at $0 still sleeps free-tier services after 15 minutes (30–60 second wake). Only paid workspaces stay warm. Railway and Fly.io do not sleep — you pay the per-second/minute meter instead.

What the Gap Collapses To on a Hetzner CX22​

Hetzner's current shared-vCPU baseline — the CX22 (2 vCPUs, 4 GB RAM, 40 GB NVMe) — lists at €3.79/month (~$4.15) with 20 TB included traffic, and the next step CX32 (4 vCPUs, 8 GB RAM, 80 GB) at roughly €8–11/month. Both numbers moved in 2026's DRAM-driven repricings, but the included-traffic allowance did not.

Put the same reference stack on one CX22:

• Both containers (API + Postgres) share the box — no per-service flat, no per-GB RAM meter, no per-volume line until you exceed the 40 GB local disk.
• 20 GB of persistent volume fits inside the 40 GB NVMe — $0 line item.
• 10 GB, 50 GB, 200 GB, or 500 GB of egress all fit inside 20 TB — $0 line item.
• Total: €3.79/month, whether egress was 10 GB or 500 GB, whether you run one service or two on the same box.

The calculus is not "Hetzner is always cheaper" — it carries the operational cost ElastiCache / managed Postgres bundles in (you patch Postgres, you run backups, you handle failover). But the meter math inverts: on hosted PaaS, every new service and every new gigabyte of egress is a new line; on a flat Hetzner box under Cluster API, those lines do not exist until the box itself is full and you add a second identical box. The first scaling step is $4.15 → $8.30, not $14 → $21 → $29.

For a Cluster-API-managed fleet, that flatness is the whole pitch: Cluster + MachineDeployment + HetznerCluster declares the node pool (CX22 as the default, CPX/CCX for dedicated vCPU when the workload needs it), and adding a second Hetzner region is a placement label, not a new pricing dimension.

When Each Platform Genuinely Wins​

Borrowing Techsy's own FAQ framing and re-grounding it in July 19 numbers:

• Pick Railway when you need the fastest git-push → running URL with a good DX and your workload is spiky or part-time — per-minute metering does beat a flat box when average utilization drops below ~30%, and the $5 Hobby credit genuinely covers a single small service plus trial.
• Pick Render when you want the closest Heroku replacement with managed Postgres (PITR, backups) and predictable flat per-service pricing — you pay more for the second service, but you do not pay a separate volume or egress meter until you exceed included bandwidth, and the workspace subscription removes per-seat surprises.
• Pick Fly.io when you need global edge placement and the lowest NA/EU egress meter — pay-as-you-go per second stays cheapest at 200–500 GB in US/EU, and Machines start fast. Budget extra lines for volumes, IPv4 if you need it, and snapshot storage if you keep them.
• Pick Hetzner (or any flat fleet under Cluster API) when the workload is always-on and you are tired of multiplying per-service flats and per-GB bandwidth — one box at €3.79 with 20 TB included swallows the two-service stack, and the next box is the same price rather than a new pricing tier.

The honest version of "which is cheapest" is three numbers, not one, and they cross between 10 GB and 200 GB of egress. That crossing point is the gap that actually moved in Techsy's July 19 re-audit — not because anyone slashed compute, but becauseRender's included bandwidth and Fly.io's regional egress tiers redrew where bandwidth bites first.

The July 19 same-date audit does not declare a universal winner. It proves a narrower, more useful point: once a stack has both compute and a database, headline per-service prices stop predicting the bill — per-service multiplication and egress decide the order. Re-run your own traffic level through the four lines above and the cheapest-to-most-expensive gap points at the right platform for your workload rather than the pricing page's hero number.

Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own. Same render.yaml-style ergonomics, but the fleet is a Cluster API fleet on Hetzner (or your own hardware) and the meter is the box you picked, not a per-service, per-GB receipt. Star the repo on GitHub or deploy your first app today.