Dora NodaVercel has changed how it charges you four times in the last 20 months. Render cut the bandwidth it includes by 95% in one update. Fly.io started billing for the network traffic it used to give you for free.
If you are trying to forecast next quarter's hosting bill, the math didn't just get more expensive. It got more dimensions.
Here is the timeline, what each change actually did to a real mid-traffic Next.js app, and why the only invoice that didn't need a changelog was the flat one from a Hetzner box.
The answer up front
A mid-traffic Next.js + ISR app — 500k page views, 80 GB egress, 2M function invocations, 10 hours of compute — costs radically different amounts depending on when you priced it and which provider's changelog you last read.
| Platform | What the same 80 GB / 2M-invocation app pays per month | What 300 GB pays | What breaks the forecast |
|---|---|---|---|
| Vercel Pro (1 seat, 2024 pre-granular) | ~$20 + $0 overage (inside 1 TB included) — compute at $0.18/GB-hour | ~$20 + $0 (still inside 1 TB) | You paid wall-clock GB-hours even while waiting on an LLM |
| Vercel Pro (Fluid + Active CPU, from June 2025) | ~$20 seat + ~$1.28 Active CPU (10h × $0.128) + ~$2.12 memory (200 GB-hours × $0.0106) + ~$1.20 invocations (2M × $0.60/M) = ~$24.60, minus $20 included credit → ~$20-25 out of pocket | Same compute + $0 bandwidth until you pass 1 TB, then $0.06-0.15/GB by region | Credit pool hides which meter you actually burned |
| Render Hobby (after Apr 23, 2026) | $0 workspace + $11.25 in bandwidth overage ((80-5) GB × $0.15) + compute | $0 + $44.25 overage | Hobby went from 100 GB included to 5 GB — overage starts 20× sooner |
| Render Pro (after Apr 23, 2026) | $25 workspace + $8.25 overage ((80-25) GB × $0.15) + compute | $25 + $41.25 overage | Even Pro's included fell from 100 GB to 25 GB |
| Fly.io (after Feb 2026) | Compute at per-second Machine rates + volume snapshots $0.08/GB/mo after 10 GB free + inter-region private networking at Machine rates | Same plus more cross-region fees if you run multi-region | Two new billed dimensions that didn't exist as lines in 2024 |
| Hetzner CX23 (flat box) | €4.35/mo (~$4.70) with 20 TB included — 80 GB, 300 GB, and 1 TB all cost the same number | Same €4.35 | No per-GB meter to watch — capacity, not consumption |
The pattern is the same everywhere: included allowances shrink, new meters appear, and the headline price stops being the bill. The next section puts dates and numbers on exactly what changed.
Four repricings in 20 months: what Vercel actually did
1. June 2024 — "Improved infrastructure pricing" goes granular
Vercel announced and rolled out granular infrastructure pricing between June 3 and July 24, 2024. Instead of two large combined meters — bandwidth and function GB-hours — the bill split into separate, individually priced dimensions with lower per-unit rates. The changelog language was "reducing pricing on Vercel fundamentals like bandwidth and functions."
In practice this meant your optimization surface multiplied. A single "functions" line became invocations, GB-hours, and later Active CPU plus provisioned memory. Lower headline rates, more meters to track.
2. February 2025 — Fluid Compute becomes the execution model
Vercel launched Fluid Compute, an approach that reuses existing resources before scaling new ones and shares one instance across concurrent invocations. It claimed 99.37% fewer cold starts and 85-90% cost reduction versus the previous model for mixed workloads. For teams, the visible change was that concurrency behavior and instance sizing changed — the default moved from standard_legacy (1 GB / 0.6 vCPU) to Fluid's Standard (2 GB / 1 vCPU).
This didn't change the price card directly. It changed what you were metering against.
3. June 2025 — Active CPU pricing replaces wall-clock GB-hours
This was the billing change that mattered most for AI-heavy and I/O-bound apps. Vercel enabled Active CPU pricing by default for all Hobby and Pro projects on Fluid Compute.
- Before: $0.18 per GB-hour of wall-clock duration. A function that waited 800 ms on an LLM response paid for 800 ms of memory + CPU whether it did work or not.
- After: $0.128 per Active CPU-hour + $0.0106 per GB-hour of provisioned memory + $0.60 per million invocations. You pay for CPU only while it is actively executing. Memory-only wait time bills at the much lower memory rate.
Vercel's own example: a Standard instance at 100% active CPU previously cost ~$0.318/hour (1.7 GB × $0.18); after Active CPU it costs ~$0.149/hour (1 Active CPU-hour + 2 GB memory). The Register's coverage quoted Vercel's claim of "up to 95% on compute costs" for I/O-heavy streaming workloads. Whether you saw 50% or 90% depended entirely on your active-CPU ratio — a number most teams didn't track until they had to.
4. Late 2025 → early 2026 — 20+ limits collapse into $20 of Universal Credit, plus Durable Functions
Two things landed together in the most recent cycle:
Universal Credit. Pro remains $20 per seat per month, but that seat now includes $20 of usage credit that applies across 20+ billed dimensions — Fast Data Transfer, Fast Origin Transfer, function invocations, Active CPU, provisioned memory, build minutes, edge requests, image optimization, and more. Hobby (free, non-commercial only) keeps hard caps with no overage — 100 GB Fast Data Transfer, 1M edge requests, 1M function invocations, 4 CPU-hours — and pauses when any limit is hit rather than billing. Pro's credit pool is more flexible than the old per-meter included quotas, but it also hides which meter triggered the overage.
Durable Functions and longer timeouts. Alongside Fluid, Vercel shipped longer execution limits and larger instance sizes enabled by Active CPU pricing, plus a Durable Functions primitive for work past the old 10- or 60-second wall. Useful for long AI tasks — and another billed surface that didn't exist two years ago.
The bandwidth line most people watch moved from ~$0.40/GB ($40/100 GB block) to ~$0.06/GB (Fast Origin Transfer) and ~$0.15/GB (Fast Data Transfer) by region — cheaper per GB, but the $20 credit that absorbs it is now shared with every other meter.
In 2023 you tracked bandwidth and duration. In mid-2026 you track invocations, Active CPU, provisioned memory, bandwidth by type and region, edge requests, builds, and image transforms.
What each revision cost a real app
Take a concrete app. Not a toy, not the worst case — a B2B marketing site plus docs plus a small API on Next.js with ISR:
- Traffic: 500k page views/month, average 160 KB delivered per view after caching (CDN helps, but ISR revalidation and uncached HTML still hit origin)
- Egress: ~80 GB/month to the public internet
- Functions: 2M invocations/month (page renders, ISR background revalidations, 4 API routes, webhook handlers)
- Compute: 10 Active CPU-hours, ~200 GB-hours provisioned memory (functions average ~200 ms active CPU per invocation, 2 GB provisioned, with I/O wait on a database and on one LLM-adjacent endpoint)
Here is what that app paid at each checkpoint. Assumptions are stated so you can re-run them for your own traffic.
| Checkpoint | How the same app billed | Over the $20 seat, what drove the delta? |
|---|---|---|
| Early 2024 (pre-granular, $0.18/GB-hour, 1 TB bandwidth included on Pro) | $20 seat + ~$36 wall-clock compute (200 GB-hours × $0.18) if all 200 GB-hours counted, but I/O wait inflated that number; no bandwidth overage at 80 GB | Duration billed the wait — an 800 ms LLM call billed 800 ms of GB-hours whether CPU was active or idle |
| Late 2024 (granular pricing active) | $20 seat + granular function pricing at reduced per-unit rates; bandwidth still inside 1 TB included | Lower per-GB-hour rates partially offset the same wait-inflated duration |
| June 2025 (Fluid + Active CPU) | $20 seat + $1.28 Active CPU + $2.12 memory + $1.20 invocations = ~$4.60 compute before credit, minus $20 credit → often $20-21 total at this traffic | 70-80% cheaper compute for I/O-bound invocations — the bill finally stopped charging for wait time |
| Early 2026 (Universal Credit) | $20 seat includes $20 credit across all meters → at 80 GB / 2M invocations / 10 CPU-hours, compute + invocations still fits inside the credit, bandwidth still inside 1 TB equivalent | If you exceed one meter you burn credit that another meter could have used — overage source is no longer obvious from the invoice header |
The other platforms tell the same story faster:
Render, same 80 GB app. Before April 2026, a Pro workspace at $19/member/month included 100 GB bandwidth — 80 GB cost $0 extra. After April 23, 2026: Hobby includes 5 GB, Pro ($25 flat for unlimited members) includes 25 GB, Scale ($499) includes 1 TB, all with $0.15/GB overage. That same 80 GB now costs $11.25 in overage on Hobby ((80-5) × $0.15) or $8.25 on Pro ((80-25) × $0.15), plus the workspace fee, plus compute. Render's own docs note legacy workspaces auto-migrate by August 1, 2026 — the lower included amount is not opt-in for long.
Fly.io, same app. In January 2026 volume snapshot storage started billing at $0.08/GB/month after the first 10 GB free. In February 2026 inter-region private networking — the WireGuard mesh between Machines in different regions — began billing at the same per-second Machine rates as compute. Neither was a billed dimension in 2024. Neither shows up in a "compare compute prices" table. Both show up on the monthly invoice for a multi-region app with routine backups.
Sensitivity: what happens when traffic doubles
| Monthly egress | Vercel Pro (Active CPU era) | Render Hobby | Render Pro | Hetzner CX23 flat |
|---|---|---|---|---|
| 80 GB (baseline) | ~$20-25 (bandwidth still inside included/credit) | ~$11.25 overage + compute | $25 + $8.25 overage + compute | €4.35 (~$4.70) |
| 300 GB | ~$20-25 + $0 until you cross ~1 TB, then ~$0.06-0.15/GB | ~$44.25 overage | ~$41.25 overage | €4.35 |
| 1 TB | First GB over ~1 TB triggers per-GB overage by region | ~$149.25 overage | ~$146.25 overage | €4.35 |
| 2 TB | ~$60-150 in bandwidth overage depending on transfer type/region | ~$299.25 overage | ~$296.25 overage | €4.35 |
This is not a claim that a Hetzner box is infinitely capable. It is a 2 vCPU / 4 GB RAM / 40 GB SSD box with 20 TB of traffic included — and yes, the CX22 generation that past comparisons quoted at €3.79 was deprecated in Q1 2026 and replaced by CX23/CX33/CX43 at slightly higher prices, and all shared-vCPU lines saw ~30% increases in 2026 while dedicated-vCPU lines (CCX/CPX) saw larger ones. The point is that the shape of the bill didn't change: traffic × 5 still produces the same number. On every metered platform, traffic × 5 produces five times the bandwidth line — or a new line you weren't tracking last quarter.
Why the invoice keeps getting wider
Three forces make the bill harder to forecast even when per-unit prices fall:
1. New features add new meters. Durable Functions, Fluid concurrency, and snapshot storage are real improvements — and each adds a billed dimension that didn't exist when you built your forecast spreadsheet. The old sheet under-prices the new platform by definition.
2. Included allowances ratchet down. Render's 100 GB → 5 GB (Hobby) and 100 GB → 25 GB (Pro), plus Vercel's shift from per-meter quotas to a shared $20 credit pool, all move the overage threshold closer to a normal app. Every repricing narrows the band where the headline price is the total price.
3. Granularity multiplies variance. Per-second billing, Active CPU, and credit pools are more efficient than flat wall-clock billing — but the bill becomes a function of more inputs (active ratio, invocation count, region, transfer type). A flat box trades efficiency for predictability: you pay even at 3 a.m. when idle, but February equals January.
What to do about next quarter
Forecasting means tracking all five meters and deciding in advance what you do when one moves again.
Collect your own baseline. Log, for a representative week, invocations per route, p50/p95 active CPU, provisioned memory, and egress by type. Two numbers — Active CPU-hours and GB-hours — explain most of the Fluid vs pre-Fluid delta.
Model egress sensitivity separately. Re-run your 80 GB month at 150 GB, 500 GB, and 2 TB. Bandwidth is the line that historically goes from $0 to larger than every other line combined. If 80 GB → 300 GB more than doubles your total, name that in the forecast.
Cap the variable dimension. Moving image-heavy egress from $0.15/GB metered to a flat 20 TB box doesn't eliminate cost — it eliminates variance. A Hetzner CX23 still costs every month, idle or not — but the pricing page no longer gets a vote on tomorrow's traffic. Cluster API Provider Hetzner (CAPH) lets a small team manage that fleet declaratively — node pools and rolling upgrades as Kubernetes objects, not tickets.
You don't need one model for everything. Many teams keep Vercel for previews while production egress rides flat hardware. Choose the billing model per workload with the sensitivity table in front of you.
The invoice that didn't need a changelog
In 20 months Vercel's pricing changed four times, Render's included bandwidth fell 95% on Hobby, and Fly.io's bill grew two new lines. In the same 20 months a Hetzner CX-class box went from €3.79 to roughly €4.35, swapped its generation label from CX22 to CX23, and kept shipping 20 TB of traffic with whatever you put on it.
Both kinds of change are real. Only one required re-doing every tenant's budget model.
If the forecasting problem resonates — four changelogs for one vendor, three platforms' pricing pages to re-audit every quarter — that is exactly the seam a self-hosted PaaS is built to close. You still pay for hardware. You stop paying for the next metering idea.
Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own. No per-seat fee, no per-GB egress meter, no new line item next quarter — just the flat box you already picked. Star the repo on GitHub or deploy your first app today.