DRIFTS Calculator

In my time as a product manager and across my years in B2B SaaS, I learned how easy it is to tolerate a known problem and just keep going. The need to keep moving becomes the default, and the problem gets filed under "we'll deal with it later." But if you stop and think about it, there's a hidden, often high cost to that inaction. With this project I set out to try and quantify what that cost could be.

DRIFTS is an interactive calculator that quantifies the hidden cost of tolerating known problems in product and delivery teams. The core insight: inaction feels free, but it isn't. The costs are invisible, distributed, and easy to rationalize away. DRIFTS makes them visible and puts a number on them, turning "we'll deal with it later" into a figure you can actually weigh.

It's not a questionnaire. You configure your team context, move a lever for each category, and watch a spider diagram and a dollar range respond live.

The six categories

DRIFTS is a framework for the six distinct ways product and delivery teams quietly bleed capacity. The categories aren't independent; they amplify each other.

• D: Decision Drag. Decisions that stall or never get made: analysis paralysis, unclear ownership, sprints losing days to approvals.
• R: Rework from Unclear Requirements. Vague tickets and missing acceptance criteria. The problem starts before a line of code is written.
• I: Invalid Assumptions Shipped. Building what nobody validated. Features that miss the mark because the bet was never tested.
• F: Fragmented Priorities. Mid-sprint scope changes and a roadmap nobody trusts or follows.
• T: Technical Debt & Incidents. Accumulated shortcuts and unplanned work that steal sprint capacity that wasn't on the plan.
• S: Slow Feedback Loops. Long release cycles and no instrumentation, the cost of learning slowly, or not at all.

How the cost model works

The number has to survive scrutiny, so the engine is built around a few deliberate principles:

• A finite capacity pool. Five categories (D, R, I, F, T) compound against a single pool of team capacity; each consumes a share of what the others leave behind, so overlapping causes are never double-counted and the internal-capacity total can approach but never exceed the team's fully-loaded payroll. A hard architectural ceiling.
• Market time kept separate. Slow Feedback (S) measures time lost building in the wrong direction, not payroll. It's reported as its own line, outside the pool and the ceiling, so the two kinds of loss are never conflated.
• Raw-dominant ledger. Each category shows its raw cost prominently, so making one problem worse never visibly shrinks another; monotonicity stays visible.
• Stage-based smart defaults. Company stage sets headcount, salary baselines, sprint length, and feature volume; a region selector shifts salaries. Everything is editable inline.
• Transparent assumptions. Every number driving the model is exposed and tunable in a Settings panel. Users who tune it get a sharper number; users who don't still get a credible default. Either way, the calculator earns its number.

The whole thing is a single self-contained HTML file: no build step, no dependencies, no backend.