Every engineering team I've worked with has the same problem: they know they have technical debt, they have a rough list of items, and they have no idea what to work on first. The backlog of debt items sits in Jira, growing longer, while the team argues about whether to fix the flaky test suite or migrate off the deprecated ORM.
Martin Fowler's Technical Debt Quadrant (reckless/prudent vs. deliberate/inadvertent) is a great conceptual model for understanding how debt originates. But it doesn't help you prioritize what to fix. For that, you need a different quadrant.[1]
Figure 1. Choose a response using both the cost of the debt and the risk of the fix.
I built this framework after one too many debates about which debt to tackle. It scores each debt item on two axes:
X-axis: Business Impact (Low to High)
How much is this debt costing in terms of delivery speed, incidents, and team morale?
Y-axis: Remediation Risk (Low to High)
How likely is the fix itself to cause problems?
HIGH RISK
|
CONTAIN | PLAN
Low impact | High impact
High risk | High risk
|
LOW IMPACT ----------+---------- HIGH IMPACT
|
IGNORE | DO NOW
Low impact | High impact
Low risk | Low risk
|
LOW RISK
These are your quick wins. The debt is actively slowing you down, and fixing it is relatively safe.[2]
Examples:
Adding missing database indexes that cause slow queries
Extracting duplicated code into shared utilities
Upgrading a dependency that's one major version behind
Adding tests to a critical path that currently has none
Fixing configuration that requires manual steps on every deploy
Action: Allocate 2-4 hours per sprint. No special approval needed. Just do it.
I was wrong about this category for years. I kept putting these items on "the list" and waiting for a designated tech debt sprint. Meanwhile, a 2-hour fix sat undone for 6 months while the team manually ran a script before every deploy. That's the definition of waste.
This is the trap quadrant. The debt isn't causing much pain today, but the fix is risky. Teams often waste energy here because the technical challenge is interesting.
Examples:
Rewriting a legacy service that works fine but "looks ugly"
Migrating to a new ORM when the current one works
Replacing a custom solution with a library for "consistency"
Action: Don't fix it. Contain it. Put guardrails around it (tests, interfaces, documentation) and move on. Revisit only if the impact increases.[5]
interface ImpactScore { deliverySlowdown: number; // 0-3: How much does this slow feature work? incidentFrequency: number; // 0-3: How often does this cause production issues? teamFrustration: number; // 0-2: How much does this affect morale/retention? customerImpact: number; // 0-2: Does this affect user experience?}// Score = sum of all factors// 0-3: Low Impact// 4-6: Medium Impact// 7-10: High Impact
Treat these scores as estimates to discuss with your team. The bands below leave a middle range that needs a judgement call before choosing high or low. Run a quick survey where each engineer rates the top 10 debt items on these four factors. Average the scores. You'll be surprised how much consensus emerges.
interface RiskScore { scopeUncertainty: number; // 0-3: How well do we understand the fix? systemCoupling: number; // 0-3: How many other systems are affected? dataRisk: number; // 0-2: Could the fix cause data loss/corruption? rollbackDifficulty: number; // 0-2: How hard is it to undo if something goes wrong?}// Score = sum of all factors// 0-3: Low Risk// 4-6: Medium Risk// 7-10: High Risk
Most prioritization frameworks tell you to fix the highest-impact items first. I disagree. Fix the highest-impact, lowest-risk items first.
Teams that start with big, risky remediation projects often fail. The project drags on, leadership loses patience, and the team loses credibility for future debt work. Starting with quick wins builds momentum, proves value, and earns you the political capital for the bigger projects.
I've seen this play out at three different companies. The team that shipped 15 small fixes in a quarter and reduced incident rate by 40% got full executive sponsorship for a major architecture initiative. The team that spent a quarter on a big rewrite and shipped nothing got their tech debt budget cut.
BEFORE STARTING ANY DEBT WORK, ASK:
1. Is the impact high or low?
High = actively slowing us down / causing incidents
Low = annoying but not blocking
2. Is the risk high or low?
High = complex fix, many dependencies, hard to rollback
Low = well-understood fix, isolated change
3. Match to quadrant:
High Impact + Low Risk = DO NOW (this sprint)
High Impact + High Risk = PLAN (RFC + dedicated capacity)
Low Impact + High Risk = CONTAIN (guardrails only)
Low Impact + Low Risk = IGNORE (fix opportunistically)
Stop debating. Start scoring. The framework makes the decision for you.
Frequently asked questions
Is this the same as Martin Fowler’s Technical Debt Quadrant?
Fowler’s model classifies how debt originates using prudent or reckless and deliberate or inadvertent choices. This post proposes a separate impact-and-remediation-risk matrix for deciding how to handle existing debt.
Should high-impact debt always be fixed immediately?
Check the risk of the remediation as well as the cost of carrying the debt. The post recommends planning high-impact risky changes, with tests, stakeholder discussion and an approach that can be delivered safely.
Are the scoring bands industry standards?
The component scores and bands are proposed discussion aids for this framework. Use incidents, delivery friction and knowledge of the change to justify the scores, then review uncertainty with the engineering leads.
When should a low-impact legacy area be left alone?
If change is risky and the current cost is low, define boundaries and tests and monitor the situation. Reassess when usage, incidents or planned product work change the impact of leaving the area as it is.
Most build vs buy decisions rely on gut instinct and flawed spreadsheets. Here's a scored framework (CORE) I've used across 130+ decisions to consistently make the right call.
My first big rewrite cost $400K and failed. The next three modernizations succeeded using a 6-phase strangler fig roadmap. Here's the complete playbook with real budget numbers.
Recognise a technical debt death spiral through delivery friction, recurring incidents and lost context, then stabilise one area and measure a focused recovery.
Compare technical debt practices from Netflix, Google and Stripe, including service ownership, code review, large-scale changes, typing and API versioning.
I replaced 183 Jira debt tickets with a 14-item Technical Debt Register and resolved 6 items in one quarter. Here's exactly what to track and what to skip.