Tech debt is invisible to the people who fund it
Engineers live with tech debt every day. They feel it in the slow releases, in the change that somehow touches ten files it shouldn't, in the quiet "we can't do that safely yet." So they raise it the only way they can, which is qualitatively. We've got a lot of debt. This part is fragile. We should really refactor that.
Leadership hears that and has nowhere to put it. Finance allocates against numbers: what does it cost, what does it return, what's the risk. "A lot of debt" answers none of those questions. So it goes up against features that arrive with revenue projections attached, and it loses. Every planning cycle, for years, until something breaks badly enough to make the conversation unavoidable.
The gap isn't that leadership doesn't care. It's that engineering talks in adjectives and finance listens for numbers, and nobody had translated between the two. That was the problem I wanted to solve.
Two numbers leadership can act on
I borrowed the vocabulary from finance, because that's the language the budget already speaks. Debt has a Principal: how big it is. Think open defects weighted by severity, plus the debt work teams have already accepted onto their backlogs. And it charges Interest: how much it hurts right now. New defects arriving faster than they get closed, a backlog that keeps growing, incidents and how long they take to resolve.
Tech Debt Score: how bad is it? How large and how painful a product's debt is, scored on a fixed scale against that product's own data. Never a ranking against other products. A team shouldn't be punished for inheriting an old, complicated system. The only question is whether this product's debt is getting better or worse.
Tech Debt Leverage: where does paying it down pay off? Interest divided by Principal. A high number means the debt hurts far more than its size would suggest, so a modest paydown buys a lot back. Below 1.0 it can usually wait. Above 2.0 it's urgent. This is the number that wins budget, because it turns a refactor from a cost into a return.
Two more dimensions put those numbers in context. Criticality is how much the product matters: customers, transactions, integrations, dependencies, revenue, regulatory and security exposure. Life Expectancy is how long it's going to be around. Together they place each product on a quadrant, and that's where ROI shows up. Debt in a critical product with a long future is worth fixing. The same debt in a system headed for retirement mostly isn't. A second view lays Remediation, the funded work actually paying debt down, against the debt itself, so you can see whether the money is going where the pain is.
How the model works
The hard part isn't picking signals. It's weighting them. A naive score just adds up raw metrics, which means it treats a cosmetic lint warning the same as a load-bearing module nobody dares touch anymore. That kind of score is noise, and people learn to ignore it fast.
So every metric is scored on the same 0 to 1 scale, then weighted twice: by how much it matters within its group, and by how much data stands behind it. The inputs are things most engineering orgs already have or can get. Defect tracking by severity, incident counts and time to resolve, the agile backlog, business metrics, regulatory and security commitments, remediation budgets and staffing. DORA delivery metrics and static analysis from tools like Sonar belong in it too. The weights also shift with a product's lifecycle stage, because debt in a product that's still growing costs something different from debt in one that's winding down.
Hand-set weights are a starting point, not the destination. The model is built to let the data take over. With Vertex AI, each metric's weight gets calibrated against what actually happens next, mainly future incidents. Metrics that predict trouble earn more weight. Metrics that predict nothing get treated as noise. That calibration needs history, six to twelve months of scores and outcomes, so it runs on top of the model rather than replacing it. And there's one guardrail I wouldn't give up: the machine learning only tunes the weights. The score itself stays a simple, explainable weighted average. If a product owner asks why their number went up, somebody has to be able to answer in one sentence.
The other decision that makes it trustworthy is confidence weighting. Enterprise data is patchy. Some products have years of clean incident history and some have almost none. When a metric has no data, it drops out instead of counting as zero, and the leverage rating is held back entirely when there isn't enough to go on. Otherwise you end up punishing teams for gaps in instrumentation rather than actual debt, and the first time a team sees that happen, they stop trusting the number. It also means the model gets sharper as new data sources come online, without a rebuild.
What changes when debt has a price
Once debt has a number, the conversation changes. It stops being a complaint engineering loses every planning cycle and becomes a line item, one leadership can rank against everything else fighting for the same budget.
A few things follow from that:
- Prioritization. Leverage plus the quadrant means you fix the debt that pays back most, in products that matter and will be around. Not the debt that's loudest in standup.
- Budgeting. Leverage gives finance a return to weigh, so paydown competes with features on even terms instead of losing by default.
- Tracking. Every weight change is versioned and remediation sits next to the score, so you can show funded work moving the number. Or not.
Two of them matter most.
First, leadership can chase ROI instead of just severity. The same debt isn't worth the same everywhere. It depends on where a product sits in its lifecycle and how much it matters to customers and the business. With the numbers in front of them, leaders can put paydown where it returns the most, instead of treating every piece of debt as equally urgent.
Second, and this is the one most organizations miss: it surfaces debt worth fixing once, in one place. In a large organization the same underlying debt often shows up across a dozen products, and every team quietly plans to fix its own copy. Measuring debt across the organization makes that duplication visible. A few teams can then take on the shared debt centrally, instead of every product reinventing the same fix on its own clock. No per-product view ever catches that. You only see it from above.
Where to start
You don't need this exact model. You need the move behind it: get debt out of adjectives and into a number the people with the budget already know how to weigh.
Start with the signals you already collect. Weight them against an outcome you actually care about. Then hand leadership two figures: how bad it is, and what they get back. The moment debt has a price, it stops being something engineering complains about and becomes something the business can choose to buy down. And that's the whole point. The engineers already feel the debt. The trick is making it legible to the people holding the budget.
I write more field notes like this one, on making agentic and enterprise systems actually work in production. Follow along on LinkedIn ↗.
The views presented are my own and do not represent those of Sabre. The figures use illustrative data.