Every new SKU, exception, tier, and special case looks affordable on its own. Added up, they form the most under-measured cost in the business — and it compounds invisibly.
A pricing exception gets approved on a Tuesday. A big prospect wants a custom contract clause; the deal is worth it, so legal writes the clause. That same month a product manager ships a variant for a vertical that asked nicely, sales spins up a new tier to close a stuck account, and ops creates a one-off fulfillment path for a partner who ships differently. Five decisions. Every one defensible. Every one approved by someone smart who could explain exactly why.
Two years later the same company can't onboard a new hire in under a quarter, every quote needs three people to sanity-check, and a "simple" change to the billing system takes a six-week project because of all the special cases nobody fully remembers. Nobody decided to make the company complicated. It happened one reasonable yes at a time.
That accumulation has a cost, and the cost is real even though it never appears on a line item. Call it the complexity tax: the recurring, compounding drag that every exception, variant, tier, and special case levies on the organization forever after — paid in slower decisions, higher error rates, longer onboarding, and the constant coordination required to keep a baroque system from falling over.
Every addition feels free
The reason complexity accrues so easily is that each new piece of it is, in the moment, nearly costless. A single extra SKU doesn't break the warehouse. One custom clause doesn't sink legal. A new pricing tier is a row in a spreadsheet. The marginal cost of any one addition rounds to zero, and the marginal benefit is concrete and immediate — a closed deal, a happy customer, a solved problem.
So the decision is always lopsided. Visible, near-term gain on one side; invisible, deferred, diffuse cost on the other. A rational person making that trade in isolation says yes nearly every time, and should. The trap isn't the individual decision. It's that the costs don't stay isolated — they pool, they interact, and they get paid by people far from the person who said yes.
Visual 1 — What you added vs. the tax it created
The reasonable yes | Why it felt free | The recurring tax it created |
|---|---|---|
One custom contract clause | Closed a six-figure deal that month | Every future contract now references it; legal review slows for all deals |
A new product variant | A vertical asked; engineering had spare cycles | Permanent line in QA, docs, support training, and the roadmap's attention |
An extra pricing tier | Unstuck one negotiation | Sales now needs a decision tree; quoting errors rise; billing logic forks |
A one-off fulfillment path | Kept a key partner happy | Ops carries an exception forever; new hires must learn the "except for…" rule |
A bespoke report | An exec wanted it once | Becomes load-bearing; nobody can deprecate it; a pipeline must be maintained |
Conceptual model. The left two columns are what gets weighed in the meeting. The right column is the cost that arrives later, every month, paid by people who weren't in the room.
Where the tax actually gets paid
The bill comes due in four currencies, none of which a budget tracks. Errors: more cases mean more ways to get it wrong, more exceptions to forget, more edge conditions that bite. Speed: every decision now has to account for more state, so quotes take longer, changes take longer, and the organization's reflexes slow. Onboarding: a new hire doesn't just learn the job, they learn the accumulated archaeology of every special case, which is why ramp times quietly stretch from weeks to months. And coordination: the more interdependent pieces exist, the more people have to talk to each other before anyone can move.
That last one is the heaviest and the most hidden. Complexity converts work that one person could do alone into work that requires three people to align first. The meeting that exists only because two systems interact in a way nobody designed on purpose — that meeting is the complexity tax, recurring weekly, forever.
It compounds because things combine
The cruelty of the complexity tax is that it doesn't grow with the number of things you've added. It grows with the number of ways those things can interact, and that number explodes far faster.
Add a tenth pricing tier and you haven't added one new thing to reason about — you've added its relationship to the other nine, to every discount rule, to the billing logic, to the sales comp plan. Complexity is combinatorial. The cost rises super-linearly while the additions look perfectly linear on the page. This is why organizations are so consistently surprised by their own sluggishness. They tracked the additions, which grew politely in a straight line, and never saw the interaction cost rising on a curve underneath.
Visual 2 — Linear additions, super-linear cost
Conceptual model. Early on, the two lines track together, which is why complexity feels affordable. The gap that opens later is the tax — the cost of every new thing's relationship to everything already there.
The taboo against subtraction
If the cost compounds, the obvious answer is to remove things. Almost nobody does, and the reason is psychological, not analytical. Removing a feature, a tier, or an exception feels like loss in a way that adding never feels like gain. Someone built it. Someone depends on it, or claims to. Killing it requires admitting that effort is now sunk, and it generates a specific, named complainer today in exchange for a diffuse, unnamed benefit tomorrow. So the asymmetry that built the complexity also protects it.
Complexity isn't the residue of bad decisions. It's the residue of good ones — which is exactly why no one can find the moment it went wrong, and why no one volunteers to undo it.
This is the contrarian truth at the center of it. If complexity came from stupidity, you could fix it by being smarter. But it comes from local rationality — a thousand correct calls that were each right in their own frame and collectively crushing. There's no villain to blame and no single bad decision to reverse, which is precisely what makes the tax so durable. Everyone was right in the moment. The organization is still slowly drowning.
What this means for leaders
Price complexity at the decision, not after. When someone proposes a new tier, variant, or exception, the question isn't "is this worth it?" — almost everything clears that bar in isolation. The question is "is this worth it given everything it will interact with for the rest of the company's life?" Force the recurring cost into the room before the yes, not into a postmortem after.
Make subtraction a routine, not a heroic event. If removing things only happens in a crisis reorg, you'll always carry years of accumulated tax between crises. Build a standing rhythm — a quarterly cull of SKUs, exceptions, tiers, reports — where killing something requires no special justification. The default should be that things expire unless defended, not that they live forever unless attacked.
Treat "no" as the scarce, valuable act it is. Saying yes is easy and feels generous; the cost is invisible and deferred. Saying no is hard and feels stingy; the benefit is invisible and deferred too. Your job is to be the person in the building who can feel the invisible cost — and who is willing to disappoint someone today to keep the organization fast tomorrow.
The fastest companies aren't the ones that never added complexity. They're the ones that kept paying it down faster than it accrued. Everyone else is running a slightly heavier organization every quarter, wondering why the same team that used to move quickly now needs a meeting to do anything at all.
A LookatBusiness original framework. Written for leaders weighing the next reasonable exception — and the cumulative, compounding cost of the ones already on the books.
