Drill 61 — The Price That 10×'d

Theme: Vendors & Dependencies · Format: 20-min drill · Difficulty: core

The story

A verification vendor announces new pricing at renewal: per-seat becomes per-API-call. Your integration was designed back when calls were free at the margin, and it shows — roughly fifty calls per application, no caching, no batching, retries stacked on top of everything. The renewal quote is 10× last year's number. Engineering says a re-architecture takes two quarters; the renewal is in six weeks.

⏸ Stop here and ask the room: what are your actual options, and when were they lost?

Run it — facilitator script

Timing: 2 min story · 10 min questions · 3 min reveal · 5 min transfer.

Read the story and pause at the ⏸. Let the room enumerate options first — pay, negotiate, rush a partial fix, switch vendors — then push on the second half of the question: when were they lost? The whole drill lives in that half.

"What does one decision cost us, per vendor, right now — does anyone know?"

Listen for: a unit-economics number, or at least where it lives — cost-per-application or cost-per-decision, tracked per vendor, visible to both the engineers who shape call volume and the people who negotiate renewals.

Weak signal: cost known only as a monthly invoice total, or engineering and procurement each assuming the other tracks it. A number nobody owns is a negotiation already lost — and this room is where you find out nobody owns it.

"Why did the architecture end up this chatty in the first place?"

Listen for: the systemic answer — the old pricing made chattiness free, so fifty calls per application was locally rational; nobody encoded "free is a pricing decision" into design review. Extra credit for spotting retries as a silent multiplier on whatever the base rate is.

Weak signal: blaming individual engineers for sloppy design. The integration was optimal against the cost surface it was built on — the failure is that nobody asked what happens when someone else moves the surface.

"When was the last moment we had real negotiating leverage?"

Listen for: "at signing" — before dependence, when walking away was cheap and both sides knew it. Strong answers connect leverage to architecture: a cached, batched integration with a rehearsed exit keeps leverage; a chatty one hands it over call by call, and the vendor can watch it happen in their usage dashboard.

Weak signal: "at renewal" — six weeks out, with the vendor reading your call volume — or treating negotiation as purely procurement's problem, disconnected from how the system was built.

Facilitator close: the reveal reframes the story — the architecture isn't the victim of the pricing change; it's the concession that made the pricing change safe to make.

The reveal

The architecture itself is the negotiating weakness. It's chatty by design, because the old pricing made chattiness free — and the vendor can see your call volume, so they know exactly what switching costs you. Re-architecting under renewal deadline pressure means paying the 10× for a year anyway, and everyone at the table knows it.

Why this happens — the mechanics

Pricing models shape architecture whether anyone intends it or not. Engineers optimize against the cost surface in front of them: when API (Application Programming Interface) calls are free at the margin, caching is complexity with no payoff, batching is premature optimization, and retry-on-anything is pure upside. Fifty calls per application isn't sloppiness — it's the rational design under that pricing. The result is that every integration is a fossil of the pricing model it grew up under, and the fossil outlives the pricing.

The flip itself is ordinary vendor economics, not malice. Per-seat pricing undercharges heavy users; usage-based pricing captures the value that chatty integrations actually consume, so the switch is their revenue strategy executed on schedule. Asymmetric attention again: to the vendor it's a pricing update in a renewal letter; to you it's your architecture repriced retroactively, with two quarters of unwinding standing between you and the number you used to pay.

Then there's the information asymmetry that decides the negotiation before it starts. The vendor sees your call volume in their own logs — they can compute your re-architecture cost and your switching cost to the dollar. You, meanwhile, learn about their pricing roadmap when the quote arrives. Leverage was maximal at signing, when you were a prospect who could walk; it decayed with every quarter of deepening integration; and at renewal-minus-six-weeks it hits zero. That's why exit and portability terms belong in the original contract — they're cheap when you don't need them and unbuyable when you do.

Diagrams

Problem — how the failure unfolds:

sequenceDiagram
    autonumber
    participant VN as Vendor
    participant AR as Architecture
    participant RQ as Renewal quote
    participant TM as Team
    Note over VN: Per-seat pricing - calls<br/>free at the margin
    AR->>VN: Fifty calls per application -<br/>no caching, no batching<br/>(silent)
    AR->>VN: Retries stack more calls<br/>on top (silent)
    Note over VN: Vendor watches call volume -<br/>knows your switching cost
    VN->>RQ: Pricing flips to<br/>per-API-call
    RQ->>TM: Quote arrives at 10x<br/>last year
    TM--xAR: Re-architecture needs two<br/>quarters - renewal in<br/>six weeks
    Note over TM,RQ: Pay the 10x for a year while<br/>unwinding your own design

Solution — where the guardrails go:

flowchart TD
    A["Vendor pricing: calls free<br/>at the margin"] --> B["Design rule: cache and<br/>batch anyway — free is a<br/>pricing decision"]
    B --> C["Calls per decision drop<br/>from fifty to a handful"]
    A --> D["Exit and portability terms<br/>negotiated at signing,<br/>while leverage exists"]
    C --> M["Cost meter: cost-per-<br/>decision tracked per<br/>vendor"]
    M -.-> AL["Pricing flip modeled the<br/>day the renewal terms<br/>arrive"]
    AL --> E["Quote scales with a<br/>handful of calls, not<br/>fifty"]
    E --> F["Renewal negotiated with<br/>credible exit options"]
    D --> F

What good looks like

• A cost-per-decision dashboard, per vendor: calls per application × price per call, tracked continuously and readable by both engineering and procurement — one number, one owner, no invoice archaeology.
• A pricing-flip stress test on the same dashboard: for each vendor, what today's volume costs under per-call, per-decision, and per-seat models — refreshed whenever terms change, reviewed before every renewal.
• A design-review question that never gets skipped: "what does this integration cost if calls are priced per unit tomorrow?" — with caching and batching as the default answer, even while calls are free.
• Call budgets per application with alerts: a target (say, five calls per decision) monitored in production, so chattiness regression is caught as drift, not discovered in a quote.
• Retry policies with caps and backoff, reviewed as cost controls — retries are a silent multiplier on whatever the vendor charges per call.
• Contract terms negotiated at signing, while leverage exists: advance-notice periods for pricing-model changes, year-one price protection or caps, and exit/portability clauses — a checklist item in procurement, not an afterthought at renewal.
• A renewal calendar with a long fuse: renegotiation prep starts two quarters out — enough runway that "re-architect first, then negotiate" is a live option instead of a bluff.

The lesson

Architecture couples to vendor pricing models — "free at the margin" is a pricing decision someone else can unmake, so design with caching and batching even while calls cost nothing. Know your cost-per-decision for every vendor, and model what a pricing flip would do before one arrives. And negotiate exit and portability terms while you still have leverage — before you're dependent, not at renewal.

Named concepts: pricing-model risk, unit economics per dependency, cost-aware architecture, negotiating leverage timing.

Real-world echoes

• Google Maps API pricing overhaul (2018). Google restructured Maps API pricing — a new billing model and a sharply reduced free tier — and many integrations built when calls were effectively free faced order-of-magnitude cost increases with a few months' notice. Chatty-by-design met a pricing flip at internet scale, and a wave of teams discovered their architecture was a line item they'd never modeled.

Transfer

For each of our vendors: what does one decision cost us today, and what would it cost if their pricing model flipped? Which of our integrations are chatty only because chattiness is currently free?

Make it a ticket: build the cost-per-decision number for our top three vendors — current pricing plus a modeled per-call flip — and put both on a dashboard that engineering and procurement read before the next renewal cycle starts.

Related

• Drill 62 — The 99.9% That Didn't Matter — the other contract term read optimistically at procurement and understood at 9 a.m. during the incident.
• Drill 63 — The Acquisition — leverage timing again: the clause you needed was only purchasable at signing.
• Drill 22 — quotas: the same rhyme with usage limits instead of price — architecture built against someone else's changeable ceiling.