Dora NodaThe same Next.js app, with no new deploys and no traffic spike, can cost a meaningfully different amount this quarter than last — not because you changed anything, but because the vendor changed how it counts.
That is what four Vercel repricings since 2024 add up to. Each one reshuffled which metered line item dominates a bill — function invocations one quarter, edge requests and bandwidth the next, image optimization after that, then the move to Fluid compute with Active CPU pricing — so an identical workload produces a different invoice depending on which pricing vintage you happen to be billed under. 2026 cost audits counting those four revisions are not arguing that Vercel is simply "expensive." They are arguing something more corrosive to planning: the formula itself moves. Finance can approve a known number, even a high one. It cannot approve a number that will be redefined twice a year.
This post puts the ledger on one page, shows what serial repricing does to a real 12-month forecast with a worked variance model, traces why the 2026 "exit from the cloud" wave of Vercel and Netlify enterprise complaints clusters around this exact risk, and contrasts it with what a fixed-price Hetzner contract running a self-hosted PaaS does to the variance term — and where that alternative stops being simpler than the vendor it replaces.
The four-repricing ledger — what moved, when, and which bill line it hit
No single Vercel changelog entry reads as dramatic. The cumulative picture does. Audits tallying four repricings since 2024 point to a pattern: each revision narrows an included allowance, reprices a metered line item, or introduces a new billable dimension — and the dimension that hurts most rotates.
| Vintage (approx.) | What changed on the pricing page | Line item that moved from "included" to "metered or repriced" | Who felt it first |
|---|---|---|---|
| Late 2024 | Function and bandwidth packaging tightened; Hobby caps clarified as hard caps with no overage purchase | Function invocations, GB-hours, and data transfer to origin/edge | Hobby and low-Pro teams whose daily builds plus ISR traffic crossed the new included thresholds |
| Early 2025 | Pro plan made "more flexible" at ~$20/mo with a $20 usage credit and pay-as-you-go beyond included quotas | Team seats ($20/dev/mo on Pro), edge requests ( | Teams scaling from 3 to 8 developers — seat math plus transfer overage hit the same invoice |
| Mid 2025 | Fluid compute introduced with Active CPU pricing ($0.128 per Active CPU hour, $0.0106 per GB-hour, $0.60 per million invocations) | Active CPU hours replaced provisioned-time accounting; Sandbox, Workflows, Queues billed on the new metric | API-heavy apps with spiky function duration — the same p95 latency now produced a different CPU bill |
| 2025-2026 rolling | Image optimization, ISR reads/writes, Blob operations/transfer, Edge Config reads/writes, and container-registry storage all itemized at per-operation / per-GB granularity | Image transformations & cache reads/writes, ISR read/write ops, Blob transfer, Edge Config ops | Content-heavy marketing sites with heavy next/image optimization and frequent ISR revalidation |
None of these rows alone looks like a price hike — some quotas even went up. The ratchet is in the composition: every revision makes more of what your app already does billable at a finer granularity, so the invoice becomes more sensitive to exactly the traffic shape you already have. The $20/mo Pro seat and the $20 included-usage credit look stable; the ten metered lines underneath them are not.
The variance model — same workload, four different bills
The question a forecast has to answer is not "what does it cost today?" It is "what will the same workload cost in 6 and 12 months if the vendor reprices again and we change nothing?" To make that concrete, fix a representative small-team workload and run it through the two pricing vintages where the audit data is cleanest.
Representative workload (one multi-service app):
- 8M edge requests / month, 600 GB transfer, 200K image transformations
- 3.5M function invocations / month, 12 GB-hours provisioned memory, ~15 Active CPU hours
- 3 Pro seats ($20/dev/mo), 150 ISR revalidations/day, 50 GB Blob transfer
Bill through early-2024 vintage vs mid-2025 Fluid/Active-CPU vintage (Pro tier):
| Line item | Early-2024 vintage (approx.) | Mid-2025 vintage (Fluid + itemized, approx.) | Delta |
|---|---|---|---|
| Seats | 3 x $20 = $60 | 3 x $20 = $60 | $0 |
| Edge requests (8M vs 10M include) | Included | Included (under 10M) | $0 |
| Transfer (600 GB vs 1TB include) | Included | Included | $0 |
| Function invocations (3.5M) | Included to ~$1-2 overage | ~$2.10 at $0.60/M (3.5 x $0.60) | +$1 |
| Active CPU (15 hrs x $0.128) | Billed as provisioned GB-hours (~$0.13-0.37) | ~$1.92 Active CPU + ~$0.13 GB-hours | +$1-2 |
| Image optimization (200K transforms) | Bulk included / lower per-K pricing | ~$1.00-3.00 at then-current per-K transform + cache ops | +$2 |
| ISR + Blob + Edge Config ops | Largely bundled | ~$2-5 itemized | +$3 |
| Subtotal (usage portion) | ~$3-5 | ~$7-12 | 2-3x on usage |
| Total with seats | ~$63-65 | ~$67-72 | +4-11% headline, +100-150% on meter |
On the headline number the move looks modest — $63 to $69. On the variable portion that actually scales with traffic, it more than doubles. That is the shape that breaks forecasting: the fixed seat fee is stable, but the part that moves with the product is being redefined each cycle.
Now extend the logic over 12 months with one more repricing assumed (the historical rate is ~2 per year since 2024):
| Scenario | 12-month cost (same workload, no growth) | Variance vs forecast made at month 1 |
|---|---|---|
| No repricing (forecast = actual) | ~$780-860 | 0% — forecast error is just traffic noise |
| One mid-year repricing matching historical average (usage portion +40-80%) | ~$810-940 | +4-9% on total, +25-55% on usage |
| Two repricings in 12 months (the 2024-2025 observed rate) | ~$840-1,020 | +8-18% on total, +50-110% on usage |
A finance team can budget for $70/mo ± $5. It cannot usefully budget for "$67 this quarter, $72 next quarter if nothing changes, $78 if the vendor reprices again, and we won't know which line item caused it until the invoice lands." The first is a cost problem; the second is a variance problem. Expensive-but-stable loses less sleep than cheap-but-moving, because only one of them can be put in a spreadsheet without a footnote that says "assume no vendor repricing."
Why 2026 became the year teams said "enough" — the enterprise complaint wave
The ledger above explains a pattern that showed up repeatedly in 2026 public complaints: teams were not leaving Vercel and Netlify because a single feature was missing, but because the pricing shape stopped being forecastable at enterprise scale. Three threads tie the anecdotes together.
1. Metered dimensions compound at the workload the marketing promised you'd build. Vercel's pitch is the frontend cloud for the Next.js app that leans on image optimization, ISR, edge caching, and serverless functions — exactly the workload that touches the most metered dimensions in the post-2024 pricing. Each dimension is cheap in isolation ($0.60 per million invocations, $0.15/GB transfer overage, a few dollars per thousand transforms). Together, on a 50K-daily-visitor marketing-plus-app site with heavy imagery and frequent revalidation, they produce an invoice where no single line item looks abusive and the total still surprises.
2. Enterprise procurement cannot sign a contract that says "price depends on next quarter's pricing page." Usage billing forces a team to forecast not just its own growth but the vendor's future pricing decisions. One repricing can be absorbed as a budget variance. Four in 18 months reads to procurement as a process — the vendor revisits the formula as a matter of course — and procurement discounts any forecast that assumes the formula stays still.
3. The parallel at Netlify made the signal harder to dismiss as one vendor's quirk. Netlify's April 2026 move to a flat $20/month Pro plan with unlimited seats was, like Render's parallel April 2026 workspace overhaul, a vendor unwinding the very seat-based packaging it had previously sold as the model. When two major frontend-cloud PaaS vendors restructure along the same axis in the same month, the read is not "both vendors had the same bad quarter." It is "seat-based packaging stopped working as a lever industry-wide, and the lever that replaced it is finer-grained usage metering" — which is exactly where variance lives.
None of this means Vercel is a bad product. The platform, its Next.js integration, and its global edge are why teams chose it. It means the risk a buyer is underwriting has changed: from "can we build on this?" to "can we forecast what building on this will cost next year, given that the meter has been redefined four times since 2024?"
What a fixed-price Hetzner contract does to the variance term
The alternative the TODO points to is not "cheaper than Vercel" in the abstract. It is cheaper in variance: a monthly hardware contract that fixes the invoice regardless of how many of those metered dimensions your traffic touches.
The mechanic is simple. A Hetzner dedicated server (AX41-class) or a CPX/CCX cloud instance is a line item at a fixed euro amount per month for the contract term. An AX41 around €47-57/mo in the pre- and post-April-2026 Hetzner repricing, a CPX31 around €15-20/mo, a larger AX52 or CCX33 higher — but in each case the contracted server does not reprice when your function invocations double, when image transforms triple, or when Fluid compute changes its CPU accounting. The invoice is set by the hardware SKU you reserved, not by how finely the vendor can count what your app does. Resize or add a server and the invoice moves; leave the fleet alone and it does not.
Put the same representative workload on owned hardware under a self-hosted PaaS:
| Cost component | Vercel Pro (variable) | Fixed-price Hetzner fleet (single AX41-class + 1-2 CPX workers) |
|---|---|---|
| Compute + edge + image + ISR + Blob | $7-12/mo usage portion today, $10-20/mo after one more repricing (same traffic) | €47-77/mo flat for the box(es) regardless of invocation / transform / ISR counts |
| Team seats | $60/mo for 3 seats | €0 — no seat meter (the control plane is yours) |
| Bandwidth overage surprises | $0.15/GB beyond 1TB; shape depends on next pricing page | Included transfer on Hetzner SKU (20TB+ on dedicated, tiered on cloud) — same each month |
| 12-month variance (same workload) | +8-18% on total if repricing rate continues | ~0% until you choose to rescale; hardware contract locks the rate |
For a one-app, one-workload comparison the fixed fleet can be more expensive at month one than Vercel's $67-72/mo all-in for the representative workload — about €47-77 is not cheaper than $67 once you account for the euro and for operating the fleet. The win is not level, it is slope: month 7 and month 12 cost the same as month 1 until you decide to add capacity, which is exactly what a 12-month forecast wants to be able to say.
Honesty requires two caveats, both of which 2026 made more visible.
Hetzner reprices too — April and June 2026 proved it. Hetzner raised cloud and dedicated prices ~30-35% on April 1, 2026 (the AX42 from €47.30 to €57.30 in the widely cited example) and again on June 15 with CPX/CCX AMD shared-vCPU lines up 113-176% on new orders. The difference that preserves the variance argument is the contract mechanic: provisioned servers keep their contracted price until a rescale or a new order. A vendor that reprices the pricing page reprices your next invoice on the same workload. A substrate that reprices the catalog reprices only your next capacity decision. That is not "no repricing risk" — it is repricing risk that you control the timing of, by choosing when to resize.
Owning hardware does not mean operating it for free. The fleet above still needs a Kubernetes control plane, a deploy pipeline (build from git, health checks, TLS), and someone to operate the cluster. The self-hosted PaaS exists to compress that cost — a Cluster API-provisioned fleet plus a PaaS control plane that gives teams Render-like git push and bex.yml ergonomics on machines they own — but the honest accounting includes the operator's time. The variance win is real; the "therefore always cheaper" claim is not, and a post that pretends otherwise would be doing the same thing the ledger criticizes: hiding the variable portion.
When serial repricing is the signal to set your own price
Not every team should leave a metered PaaS, and not every workload rewards owning hardware. The decision rule is simpler than a TCO spreadsheet: leave when the dominant cost risk you face is no longer level but variance.
Stay on metered if:
- Your traffic is genuinely spiky and brief (campaigns, bursty preview deploys) and your bill's variable portion is a small fraction of the total.
- You have no one who will operate a fleet and no appetite to become that team this year — operational variance can be worse than pricing variance.
- You can pass through repricing to your price or your customer (internal tool, funded prototype).
Fix your own price if two or more of these are true:
- You have been surprised by the same invoice twice in four quarters without changing what you ship — that is serial repricing, not growth.
- Your workload touches three or more metered dimensions (functions + images + ISR + edge + Blob on Vercel is the canonical set) so any single repricing can find you.
- Procurement or finance has asked you to "put a number on next year" and you had to add a footnote that says "assumes no vendor repricing" — that footnote is the risk.
- You already run or plan to run a second workload that can share a fixed fleet (staging, a second service, a side project) — the flat box gets cheaper per tenant as soon as it is shared.
A practical cheap test before committing: model one month of your actual Vercel usage through both the January 2025 and the June 2025 pricing vintages using your real invocation / transfer / transform counts from the dashboard. If the delta exceeds your team's monthly variance budget (for many small teams, $15-25/mo is enough to break a forecast), you have measured the risk without migrating anything.
The bottom line: finance does not need the cheapest line — it needs a line that stays still
Four repricings since 2024 is not a story about one vendor being greedy. It is a story about a pricing shape that optimizes by redefining the meter: each revision is small and defensible, and four of them compound into an invoice that no longer answers to the forecast made at the start of the year. That is why enterprise complaints in 2026 cluster the same way, and why Netlify and Render repricing along the same axis in the same month reads as an industry signal rather than a coincidence.
A fixed-price Hetzner contract does not make hosting free, and — after April and June 2026 — it no longer lets a self-hosting pitch pretend that owned hardware is repricing-proof. What it does is move repricing risk from "the vendor can change your next invoice" to "you choose when your next capacity decision reprices" — which, for a team that needs to put a number on next year's hosting line and have it still be true, is the difference between a budget and a bet.
Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own. Fixed-price Hetzner hardware plus a PaaS control plane that speaks the same deploy-from-git, preview-environment, custom-domain language your team already knows, without a meter that gets redefined next quarter. Star the repo on GitHub or deploy your first app today.