Putting a Price on Tech Debt — Jorge Barrera
J · BARRERA
NOTES
← ALL WRITING Field note 01 · Tech debt

Putting a Price on Tech Debt

Every engineering org has tech debt. Very few can tell leadership what it actually costs them. "We have a lot of tech debt" is a feeling, and you can't put a feeling in a budget. Here's a way to turn it into two numbers leadership can act on.

Jorge Barrera · November 2026 · 6 min read

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.

Leverage scaleLeverage = Interest ÷ PrincipalHow much the debt hurts, relative to how big it is.CAN WAITWATCHURGENT01.02.03.0+Big backlog, rarely touched: 0.6Big backlog, rarely touched0.6Steady drag on every release: 1.4Steady drag on every release1.4Small debt, constant incidents: 2.6Small debt, constant incidents2.6Illustrative values · capped at 5.0
Fig. 1 — Leverage: where paying debt down buys the most back.

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.

Criticality and life expectancy quadrantINVESTFix the debt: it pays backCONTAINProtect it until it's replacedSCHEDULEFix it when it's convenientLET IT RETIREDon't spend on itShortLongLife expectancy →LowHighCriticality →Product G: leverage 0.5Product A: leverage 2.6Product E: leverage 2.4Product D: leverage 0.8Product B: leverage 1.6Product F: leverage 1.2Product C: leverage 2.2Product H: leverage 0.9Product A · 2.6Product B · 1.6Product C · 2.2Product D · 0.8Product E · 2.4Product F · 1.2Product G · 0.5Product H · 0.9Circle size = size of the debt (Principal). Color and number = Leverage:below 1.0, can wait1.0 to 2.0, watchabove 2.0, urgentIllustrative data
Fig. 2 — Criticality against life expectancy. The top-right is where debt paydown earns its budget.

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.

How the model worksINPUTSSCORE & WEIGHTFOUR DIMENSIONSOUTPUTSDefects by severityIncidents & time to fixAgile backlogBusiness metricsRegulatory & securityRemediation & staffingDORA & SonarScore every metricon a 0 to 1 scaleWeight each metricimportance × confidence× lifecycle stagePrincipalHow big the debt isInterestHow much it hurts nowCriticalityHow much it mattersLife expectancyHow long it will be aroundTech Debt ScoreHow bad is it?LeverageInterest ÷ PrincipalThe quadrantWhere's the ROI?Vertex AI calibrationWeights tuned against future incidentsfuture incidentsrecalibrated weights
Fig. 3 — How the model works. Machine learning only tunes the weights; the score itself stays an explainable weighted average.

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.

Fix shared debt oncePER PRODUCTSEEN FROM ABOVEProduct 1same debtProduct 2same debtProduct 3same debtProduct 4same debtProduct 5same debtProduct 6same debt6 teams, 6 separate fixes, 6 schedulesEvery product plans its own copy of the fix.P1P2P3P4P5P6One shared fixowned by a few teams, centrally1 fix, 6 productsVisible only when debt is measured across the org.
Fig. 4 — The same debt, seen per product and seen 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.

Working the same problems I'm writing about?

Contact me →