The 90% margin is gone

For thirty years, software ran on a beautiful piece of physics: once the product was built, serving one more user cost approximately nothing. Marginal cost ≈ 0 meant growth was margin. Every new customer was nearly pure gross profit, and the entire economic machinery of the industry — pricing, valuation, hiring plans, the 80–90% gross margins investors expect — was built on that assumption.

AI broke the physics. Every session now burns metered inputs: tokens processed, minutes transcribed, speech synthesized, GPU-seconds consumed. For the first time since software ate the world, software has a cost of goods again — one that arrives on invoices, varies with usage, and grows with success. The companies feeling it first split into two groups, with two different versions of the same problem.

The sell-side mismatch: flat price out, variable cost in

If you sell an AI product, your price was fixed the day the contract was signed. Your cost moves with every conversation.

A customer pays the same subscription whether their users hold three-minute sessions or thirty-minute ones, whether they run the product once a day or lean on it all afternoon. Nothing in a flat price responds to that variance — so the variance lands on you, as margin. The heaviest users of your product are, by construction, your most under-priced customers, and a flat price guarantees you won't see it until month-end.

That's the sell-side shape: revenue fixed at signing, cost decided by user behavior, and the gap discovered on an invoice. A product can be growing beautifully by every top-line measure while its gross margin quietly walks downhill — not because anything is broken, but because the pricing was written for software that cost nothing to serve.

The buy-side mismatch: the tools arrived, the controls didn't

If you buy AI, the problem inverts. Adoption outran accountability.

In two years, AI went from one experimental API key to a sprawl: multiple model providers, coding assistants on per-seat plans, embedded AI in half the tools already in the stack, and teams spinning up their own usage under their own keys. The finance function sees the totals — several invoices, growing — and almost nothing else. Which teams spend what? Which projects justify their share? Which seats are actually used? The invoice doesn't say.

Most organizations do have an AI policy. It tends to live in a document: who may use which tools, what data may not be pasted where, guidance by role. What it almost never has is a meter or a limit. The tools arrived; the controls didn't. Spending guidance that nothing enforces isn't control — it's a hope with a letterhead, and the bill arrives regardless.

The rhyme, and why this cycle is faster

We have run this experiment before. Cloud spend in the 2010s followed the same arc: an explosion of easy adoption, then bill shock, then — nearly a decade later — a mature discipline (FinOps) with tagging, showback, budgets, and teams whose whole job is cloud unit economics.

AI spend is the new cloud bill, and the arc is repeating with two differences. First, it's faster: what took cloud a decade is compressing into roughly three years, because the playbook exists and the bills are growing more steeply. Second, the stakes sit closer to the product: cloud waste was an infrastructure line; AI cost lives inside your gross margin (sell-side) or your headcount-level budgets (buy-side). It's not a platform team's problem — it's a P&L problem.

The companies that came out of the cloud cycle strongest weren't the ones that spent least. They were the ones that got control earliest — while competitors were still discovering their bills, they already knew their unit costs and priced, planned, and negotiated accordingly. The same window is open now, and it's shorter.

What this handbook does

The fix is not a spending freeze, and it is not a spreadsheet heroically rebuilt every month-end. It is a method, and it's the same method for both sides of the mismatch:

1. Pick your unit — the thing you sell or the thing you budget (chapter 2).
2. Understand what makes it expensive — starting with the trap that breaks everyone's averages (chapter 3).
3. Attribute every dollar to it — including the dollars that resist (chapter 4).
4. Price against it or budget against it — depending on which side you're on (chapters 5 and 6).
5. Make it hold — with controls that live where spend happens, on a 30-day path (chapter 7).

None of it requires new economics. It requires taking seriously a sentence the industry spent thirty years not needing: your software has a cost of goods now, and somebody should know what it is.