The Four PaaS Pricing Pages You Must Re-Audit in Q3 2026: Railway, Render, Fly, and Vercel After Active CPU

If you priced your stack in January and haven't looked since, you're budgeting against a pricing page that no longer exists. In Q3 2026 every major PaaS moved a different lever — Railway tightened its usage-credit math, Render rewrote its egress allowance, Fly.io turned two previously bundled items into metered lines, and Vercel landed its fourth pricing change in two years with Active CPU. One of those changes probably already affects your next invoice.

This post re-audits all four on one page. We reconstruct how each platform actually bills in August 2026, what Vercel's four-step repricing sequence changed, and where a concrete mid-traffic workload lands on each bill versus a flat Hetzner box. No vendor page does that comparison for you.

The Four Models at a Glance​

The headline difference isn't price — it's what counts as billable.

Keep that table open. Every section below fills in its row with the line items that move first when traffic grows.

Railway: Usage-Based With a Credit That Isn't a Cap​

Railway's model is the simplest to explain and the easiest to misread. You pay $5/month on Hobby or $20/month on Pro, and that fee is not a service allowance — it's a usage credit. Every second a service runs, Railway meters vCPU time at roughly $0.00000772/vCPU-second (about $20/vCPU-month) and RAM at $0.00000386/GB-second (about $10/GB-month), plus $0.15/GB-month for volumes and $0.05/GB for egress. The plan fee just pre-pays that meter.

What that means for a realistic stack:

Worked example — two always-on Node services (API + web), 512MB RAM / 0.5 vCPU each, 50GB volume, 100GB egress for the month.

• Compute: ~$10 (0.5 vCPU) + ~$5 (0.5GB RAM) per service × 2 = ~$30
• Volumes + egress: ~$7.50 + ~$5 = ~$12.50
• Minus Hobby $5 credit = ~$37 billed? No — Railway's docs note most small apps land at $5–20/month precisely because the per-second rates are quoted at full-month-equivalent but real CPU time for a lightly loaded API is far below 100% utilization. A lightly loaded API averaging 5% CPU burns roughly $0.50–1/month in vCPU, not $10.

That gap between "provisioned price" and "utilized price" is Railway's whole story. An always-on 1 vCPU box that sits idle still burns per-second CPU ticks — low, but never zero, unlike Vercel's Active CPU — so two small services realistically clear the Hobby credit and land around $12–18/month before egress. Railway disabled its CDN in May 2026, so every byte now traverses origin egress rather than being absorbed at the edge — a subtle push upward on the egress line that didn't exist last year.

When Railway wins: Prototypes and environments with few services and spiky-but-idle workloads where average CPU stays low. When it doesn't: Multiple always-on services with steady CPU — the credit is quickly exhausted and you pay the full per-second rate 730 hours a month.

Render: Fixed Per-Service, but Egress Is the Meter That Moves​

Render is the inverse of Railway. Compute is fixed: you pick an instance type (Starter at $7/month per service is the current floor for always-on, with higher tiers for more CPU/RAM) and you pay that whether the service does 1 request or 1 million. Volumes attach to paid services. The platform's April 23, 2026 workspace restructuring is what re-audit readers must catch.

On April 23, Render moved from subscription-plus-add-ons to workspace-based plans and, critically, slashed included bandwidth. Hobby went from a flat 100GB to 5GB included, Pro to 25GB included, with overage at $0.15/GB. Every legacy workspace auto-migrates by August 1, 2026. For apps that serve images, JS bundles, or video, egress — not compute — is now the first meter to bite.

Worked example — API + web + Postgres, each on Starter ($7 × 3 = $21), 50GB disk, 200GB egress.

• Compute: $21 (three services, fixed)
• Egress: 200GB − 25GB (Pro included) = 175GB × $0.15 = $26.25
• Total: ~$47.25/month before databases — and $26 of it is bandwidth that used to fit inside the old 100GB allowance.

A 200GB month that cost ~$21 + $15 overage (100GB free) under the old allowance now costs ~$21 + $26.25 — an 18% increase from a single allowance change, before any instance price moved. Render's free tier, meanwhile, still spins down after 15 minutes of idle (about a one-minute cold start), so it remains fine for demos and broken for anything with user-facing latency expectations.

When Render wins: Few services, bandwidth-light APIs where fixed compute is predictable and egress stays under 25GB. When it doesn't: Media-heavy or high-traffic frontends where 200–500GB egress dwarfs the instance bill — the $7 service looks cheap until the $0.15/GB line doubles it.

Fly.io: Per-Second Machines — And the Two Lines That Weren't There in January​

Fly.io bills Machines per second for the entire time they are started, even at zero traffic. A shared-cpu-1x with 256MB that stays started all month is about $2.02/month in raw compute — Fly's famous floor price — but production apps aren't one shared-cpu toy. A performance-1x with 2GB left provisioned runs roughly $32/month, and every Machine (web, worker, replica) bills independently. Auto-stop mitigates idle cost, but only if you configure it aggressively.

The 2026 change that triggers the re-audit is not the base rate but two new meters that didn't exist in 2025:

1. Volume snapshots — January 1, 2026: $0.08/GB-month for snapshot storage (first 10GB free). Default retention keeps multiple snapshots, so real cost runs 2–5× the raw per-GB rate. A 50GB volume with three retained snapshots bills ~$12/month in snapshots alone, not $4.
2. Inter-region private networking — February 2026: Traffic between regions over Fly's WireGuard mesh now bills at $0.01/GB in / $0.02/GB out, with same-region traffic still free. Managed Postgres replication across regions falls squarely into this line.

Worked example — three Machines (web + API + Postgres), 50GB volume with 3× snapshots, 100GB inter-region replication traffic.

• Compute: ~$15–35 depending on sizing and auto-stop aggressiveness
• Snapshots: ~50GB × 3 × $0.08 − 10GB free ≈ $11–12
• Private networking: 100GB × ~$0.015 blended × direction ≈ $1.50–2
• Total delta from "what used to be free": +$13–14/month that last year's budget sheet shows as $0

Fly also published interim pricing comparisons in early 2026 noting Railway bills $20/vCPU-month and $10/GB-month per second while Fly bills per-Machine second — the right mental model is that Fly rewards aggressive auto-stop and punishes "leave everything started," whereas Railway always bills low-idle CPU even though it never sleeps.

When Fly wins: Workloads that can auto-stop aggressively or reserve compute blocks, and single-region deploys with minimal snapshot retention. When it doesn't: Multi-region apps with always-on Machines and standard snapshot retention, where the two new lines add a second rent check on top of compute.

Vercel: Four Repricings to Active CPU — What Actually Changed​

No platform in this set moved its pricing more often. Vercel's sequence from 2024 to 2026 is the context most teams misprice against because they remember the page from whichever change they last noticed.

The conceptual shift in steps 2–3 is what deserves the re-read. Before Active CPU, a function waiting 2 seconds on an LLM response billed 2 seconds of GB-seconds. Now it bills near-zero CPU for that wait — only the milliseconds where your code touches the CPU. Vercel's own launch framing calls this "lower pricing with Active CPU" because AI-heavy workloads, which spend most wall-clock time idle, see the largest drop. The pricing metrics became:

• Active CPU time (CPU actually executing) — the new primary driver
• Provisioned memory — still billed while the instance holds it
• Invocations — per-request fees remain

For a non-AI API, the difference is modest; for an agent that chains four LLM calls and waits ~8 seconds wall-clock but burns only 200ms of CPU, the old model taxed the wait and the new one doesn't. That's why Vercel rebuilt its compute model twice in 18 months — per-invocation serverless metering fundamentally penalizes idle-wait workloads, and AI workloads are almost all wait.

Illustrative delta — 1M function invocations, 300 vCPU-hours of Active CPU, 2TB egress, 1 seat Pro ($20).

• Active CPU (300 hrs): ~$19–38 depending on instance class (Vercel's listed rate versus third-party recomputes varies by CPU tier)
• Egress (2TB, 1TB included on Pro): ~$150 at $0.15/GB overage
• Pro seat: $20
• Note: this is where Vercel's bill concentrates differently than Railway/Render/Fly — egress and Active CPU are separate knobs, and 2TB of egress dwarfs compute on every platform.

Teams that last priced Vercel against the pre-2024 blended bundle are under-counting invocations and over-counting idle tax; teams that priced it last quarter may still be modeling GB-seconds instead of Active CPU.

Same App, Four Bills — Head-to-Head Recompute​

This is the table the vendor pages won't give you. One representative mid-traffic workload, priced once on each platform's August 2026 meters, against a flat Hetzner baseline.

Workload assumptions: Next.js frontend (SSR + API routes), Postgres, ~500k requests/month, ~200GB egress, 50GB volume, two app services plus DB. Not cherry-picked for any vendor — it's the kind of "past hobby, not yet scale" app that makes the PaaS-vs-flat-box decision real.

A few things that table makes concrete:

• On this volume, egress decides the winner more than compute. Render's egress line alone eclipses its instance bill; Railway's $0.05/GB is the cheapest per-GB but its no-scale-to-zero compute never drops out; Fly's two new 2026 lines add ~$13 before egress even counts; Vercel's 1TB Pro allowance makes 200GB look free but 2TB makes it dominant.
• The range matters. Fly at ~$30 assumes aggressive auto-stop and same-region Postgres; Fly at ~$55 assumes always-on Machines with multi-region replication. Railway at ~$35 assumes low average CPU; peg one service at sustained 50% CPU and add ~$10/month. Single-point comparisons hide more than they reveal — sensitivity is the point.
• Hetzner's flat box is not "cheaper at any cost." At ~$5–6/month with 20TB included bandwidth, it wins raw cost for this workload by 5–9× — but that number excludes operational labor, which is exactly what a PaaS bills for. The comparison is honest only if you name the trade: metered convenience versus owning the machine and its remediation queue.

How to Read Any PaaS Pricing Page Going Forward​

Pricing pages oscillate between "we cut prices" and "we added granularity." Both can raise your bill. Five questions catch the drift before it lands on your invoice:

• What does idle cost? Always-on per-second (Railway, started Fly Machines, fixed Render instances) versus scale-to-zero/Active CPU (Vercel Fluid). If you run cron jobs or low-traffic staging, idle dominates.
• What's the egress story? Included allowance, per-GB overage, and whether CDN/static traffic counts. Render's 100GB→5/25GB shift is a textbook example of allowance being the real price.
• Are snapshots, backups, or private networking billed separately? Fly's Jan/Feb 2026 lines are a pattern, not an exception — managed services monetize bundled primitives as they mature.
• Is the entry fee a credit or an allowance? Railway's $5/$20 is a credit against metered usage, not a cap. You clear it and keep paying. Render's fixed tiers and Vercel's seat are allowances with hard shape.
• Which dimension bursts first for your app? Image-heavy frontends burst egress; chatty APIs burst invocations/Active CPU; multi-region bursts snapshot and private-net. Model the dimension your app actually stresses, not the headline rate.

Re-audit on that checklist each quarter. The platforms aren't hiding price hikes — they're moving the meter that matters to a different line, and only a same-workload recompute surfaces it.

Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own. If this comparison has you pricing a flat Hetzner box with honest bandwidth, star the repo on GitHub or deploy your first app today.