Your PaaS Bill Lied to You: Run a Bill-Forensics Audit Before You Migrate

He budgeted $20 a month and opened a bill for $286. That is the opening anecdote of Tural Allahverdiyev's June 2026 essay "Your PaaS Bill Lied to You," a line-by-line comparison of Railway, Render, Fly.io, and Vercel that struck a nerve because nearly every team running on a PaaS has lived some version of it: the plan you signed up for no longer describes the invoice you pay. The seat fee you budgeted is now a footnote. The meters you never configured — build minutes, snapshots, egress IPs, preview environments — did the rest.

This post is the operational sequel to that essay: a bill-forensics checklist you can run on your own invoices this afternoon. Not another price table — we already published the same workload priced on every vendor's September 2026 price list — but a method. Here is the whole audit up front; the rest of the post works it end to end.

The drip, vendor by vendor, 2024–2026​

Step 2 needs raw material: what actually changed on each price list since 2024. Here is the dated ledger.

Fly.io unbundled. The permanent free allowances are gone, replaced by a free trial (2 VM hours or 7 days, whichever comes first), and the old Hobby, Launch, and Scale plans were deprecated. Then 2026 added genuinely new metered lines: volume snapshot billing at $0.08/GB-month (first 10 GB free) started charging early this year, and app-scoped static egress IPs began billing January 1 at $3.60 per month per IPv4 — both lines that used to ride along for free. The pattern to look for on your invoice: small new lines next to one large old one, because Fly.io Managed Postgres Basic still opens at $38 plus $0.28/GB before your app serves a byte.

Vercel repriced the build and the seat, repeatedly. Pro sits at $20 per seat per month, and since February 2026 new Pro projects default to Turbo build machines (30 vCPUs, 60 GB of memory) at $0.126 per minute — roughly 9x the standard build rate, applied to the builds you were already running. Edge Config moved from package-based to per-unit reads and writes (and has since been renamed Global Config). Zoom out one more year and the December 2024 deprecations of Vercel Postgres and Vercel KV pushed database spend onto Neon and Upstash invoices entirely outside the Vercel bill — the purest form of bill fragmentation, since the charge disappears from the invoice you audit without disappearing from your budget. Bandwidth overage at $40 per 100 GB remains the line that converts a traffic spike into a finance incident.

Render replanned around flat teams. On April 23, 2026, Render replaced $19-per-seat team pricing with a flat $25-per-month Pro workspace covering unlimited members — an instant $70 monthly cut for a five-person team, and a rare case where step 4 of the checklist delivers good news. The offset, and there is always an offset: paid web services start at $7, the included bandwidth allowance shrank, and overages moved to $0.15/GB. Render's bill got more predictable on seats and more metered on traffic in the same announcement.

Railway flattened the fee and kept the meter. Railway's Pro plan is now $20 per workspace with $20 of included usage and unlimited seats — a flattening that landed after Render's and reads the same way: the platform fee is now a rounding error next to usage rates of roughly $20 per vCPU, $10 per GB of RAM, and $0.05 per GB of egress per month. A Railway invoice is the closest thing in this set to a raw materials bill, which makes step 3 (classification) almost trivially easy and step 5 (meter audit) the entire game.

Heroku froze — that is the trap, in one paragraph. The February 6 "An Update on Heroku" post moved the platform to sustaining engineering: no new features, maintenance only. Nothing on the price list moved — Standard-1X is still $25, Standard-2X $50, Postgres Standard-0 $50 — which means a Heroku bill-forensics audit finds zero drift and still recommends action, because you are paying full price for a platform guaranteed never to improve.

The bill-forensics checklist, in full​

With the ledger above as your reference price list, run the six steps.

Step 1: Pull three invoices. Latest, six months ago, and the oldest you can still download (the signup-era shape of your bill). Export line items, not totals — every vendor above now itemizes, and the totals hide the story. If you cannot get the signup-era invoice, the Internet Archive's snapshots of the vendor's pricing page from your signup month are an acceptable substitute for step 2.

Step 2: Diff against the price list you signed up on. For each current line, ask: did this line exist when I signed up, at this rate, with this allowance? Flag three kinds of change: brand-new lines (Fly.io snapshots and egress IPs are the 2026 archetype), repriced lines (build minutes that quietly moved to Turbo rates), and moved allowances (bandwidth included allowances that shrank while the headline plan price stayed put). The third kind is the one teams miss most, because no announcement ever leads with "we cut your included allowance."

Step 3: Classify every line. Mark each line fixed (platform fee, per-service base), usage-scaled (compute, RAM, egress, build minutes, storage), or new-since-signup. Then total the three buckets. The ratio that matters is usage-scaled as a share of the bill: under a third, your bill is predictable and the audit is mostly hygiene; over half, your bill is a function of traffic and deploy frequency, and you should treat it as a variable cost with a monitoring problem, not a subscription with a budgeting problem.

Step 4: Recompute the seat math. Both Render and Railway replaced per-seat team pricing with flat workspace fees in 2026. If your headcount grew since signup, rerun your current seats on both the old and new math — teams of five-plus almost always win on the replan, solo developers sometimes lose. Vercel is the exception that proves the rule: still $20 per seat, so every hire is a step function on the invoice. Project the seat line at your headcount twelve months out, not today.

Step 5: Audit the big three meters. Egress, build minutes, and preview environments cause a disproportionate share of surprise bills. For egress, find your per-GB overage rate ($0.40 on Vercel, $0.15 on Render, $0.05 on Railway, $0.02 on Fly.io) and multiply it by a 10x traffic month — that number, not your median month, is your exposure. For builds, check whether you are on Turbo-class machines and how many builds each PR triggers. For previews, count how many environments run concurrently and whether they bill per second as full services (Render, Railway, Fly.io all meter running preview machines; the cost hides inside compute lines, not a labeled "previews" row).

Step 6: Normalize and decide. Convert the audited bill to cost per deploy (monthly total divided by deploys) and cost per seat. These two ratios are the only fair basis for the migrate-vs-stay decision in the next section, because headline plan prices no longer describe anyone's invoice.

Worked example: forensics on a five-person team's invoice​

A concrete walkthrough, using typical September 2026 list prices for a realistic small-production stack: one web service (~1 vCPU / 2 GB), one worker, managed Postgres (~10 GB), three preview environments live roughly a quarter of the month, five seats, 100 GB of egress. (Our one-ledger post prices this exact workload on all five vendors; what follows is the forensics reading of the Railway row, the closest modern analogue to the essay's $286 story.)

The invoice totals roughly $122: $20 workspace fee, ~$40 web compute, ~$20 worker compute, ~$42 Postgres (metered compute plus volume), ~$15 previews, ~$5 egress. Step 1–2 diff: the workspace fee is new-since-signup in the good direction (it replaced $20-per-seat billing, saving this team $80 against the old math). Nothing else is new — which is precisely the finding. Step 3 classification: $20 fixed, ~$102 usage-scaled. Eighty-four percent of this bill moves with usage.

Step 4 seat math: seats are now irrelevant to this invoice — $0 marginal cost per hire. Step 5 meter audit: previews at ~$15 are the single most controllable line (shorter environment lifetimes, fewer concurrent previews), and egress at $5 is calm only because 100 GB is modest; a 10x traffic month adds $45, which the team should price as exposure rather than discover as surprise. Step 6 normalization: at 100 deploys a month, this stack costs ~$1.22 per deploy and ~$24 per seat — numbers that make the "we pay $20 for Railway" mental model off by 6x.

The verdict this forensics run produces: the bill did not lie about any single line, and every line is defensible in isolation. The lie was the category error — budgeting a variable-cost meter as a fixed subscription. That verdict points at monitoring and preview hygiene first, vendor migration second, and it is the verdict the checklist exists to produce before anyone starts a migration.

The decision rule: migrate, renegotiate, or self-host​

Forensics without a decision is trivia. Apply the audited numbers to this rule:

• If usage-scaled lines are under a third of the bill: stay and re-audit quarterly. Your bill is predictable; migration economics cannot beat the switching cost. This is where flat-fee Render workspaces and small Fly.io deployments usually land.
• If one meter dominates (over half the bill): attack the meter before the vendor. Preview hygiene, build-minute reduction, egress caching, and Turbo-machine opt-outs are all cheaper than a migration and survive one — you will want them on the next vendor too.
• If the audited total exceeds 2x the flat-rate self-host anchor for three consecutive months: price the self-host move seriously. The anchor for this workload class is an AX41-class Hetzner dedicated box at roughly $45–55 per month all-in, on which the web service, worker, self-run Postgres, and previews all ride for $0 marginal — with a 20 TB-class bandwidth allowance that makes the egress-exposure math above evaporate. Two caveats the checklist forces you to price honestly: Hetzner repriced in June 2026 too (cloud servers moved most; dedicated moved less), so re-verify the anchor rather than trusting memory — and the anchor excludes your ops time, which is the real migration cost for teams without platform headcount.
• Sensitivity first: rerun the verdict at one seat and ten seats (seat math flips Render and Vercel rows hardest), at 100 GB and 1 TB of egress (Vercel's $0.40/GB flips hardest), and with previews on and off. If the verdict survives all three swings, it is real. If one variable flips it, that variable — not the vendor — is your decision.

One pattern the ledger makes visible: 2026's replans moved every vendor toward flat platform fees plus usage meters, which means the migration question is increasingly not "which vendor is cheaper" but "which vendor's meters match my workload's shape." Egress-heavy static workloads belong away from per-GB bandwidth vendors; seat-heavy teams belong away from per-seat vendors; spiky preview usage belongs where previews bill per second or not at all. The checklist's classification step is what tells you your shape.

Bills will keep lying — audit quarterly​

The drift this post catalogs is not a 2026 anomaly; it is the business model converging. Free tiers became trials, seat fees became flat fees, and the margin moved into meters — snapshots, egress IPs, build machines, bandwidth overages — that no signup page ever headlined. Allahverdiyev's $286 bill was not an error and not an outlier; it was the predictable output of budgeting a meter as a subscription. The fix is procedural, not vendor-specific: pull three invoices, diff the lines, classify the meters, and rerun the decision rule every quarter, because the price list you signed up on no longer exists at any vendor in this post — Heroku included, where the price list froze and the platform froze with it.

Running the audit and finding the meter is the problem, not the vendor? Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own, where the invoice is a flat server bill you can audit in one line. Star the repo on GitHub or deploy your first app today.