Skip to content

The Technical Debt Quadrant: A Framework for Prioritization

A practical four-quadrant prioritization framework for technical debt that tells you exactly what to fix now, what to plan, and what to ignore.

8 min read
Illustrative four-compartment tray holding engineering parts with different wear and complexity.
On this page

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]

The Prioritization Quadrant

High risk Low risk Low impact High impact CONTAIN Guardrails and boundaries PLAN RFC and dedicated capacity IGNORE Fix opportunistically DO NOW High impact, low risk
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

Quadrant 1: DO NOW (High Impact, 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.

Quadrant 2: PLAN (High Impact, High Risk)

These are your strategic investments. The debt is painful, but the fix is complex enough to require planning.

Examples:

  • Migrating from a monolith to services
  • Replacing a core data store
  • Rewriting the authentication system
  • Major framework upgrades (e.g., Angular to React)

Action: Write a proper RFC. Get stakeholder buy-in. Allocate dedicated capacity. Use the strangler fig pattern where possible.[3][4]

Quadrant 3: CONTAIN (Low Impact, High Risk)

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]

Quadrant 4: IGNORE (Low Impact, Low Risk)

These are items that could be fixed easily but provide minimal value. Fix them opportunistically when you're already touching that code.

Examples:

  • Renaming variables to better conventions
  • Reformatting code that doesn't match current style guide
  • Removing unused feature flags from non-critical paths

Action: Don't plan work for these. Fix them during code reviews or when working on adjacent code.

How to Score Debt Items

Business impact Delivery, incidents, morale, customers Remediation risk Scope, coupling, data, rollback Team review Discuss estimates and uncertainty
Figure 2. Use the scores to expose assumptions that need discussion.

Scoring requires data, not opinions. Here's how I assess each axis.

Scoring Business Impact (0-10)

typescript
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.

Scoring Remediation Risk (0-10)

typescript
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

The Prioritization Template

Here's a spreadsheet template you can use immediately:

Debt Item Delivery (0-3) Incidents (0-3) Morale (0-2) Customer (0-2) Impact Total Scope (0-3) Coupling (0-3) Data (0-2) Rollback (0-2) Risk Total Quadrant
Payment API coupling 3 2 2 1 8 2 3 1 1 7 PLAN
Missing DB indexes 2 1 1 2 6 0 0 0 0 0 Team judgement
Legacy CSS framework 1 0 1 0 2 1 2 0 1 4 Team judgement
Auth session handling 2 3 2 2 9 3 2 2 2 9 PLAN

Working the Quadrants: A Quarterly Process

Week 1 of the Quarter: Inventory

Gather your debt items. Sources:

  • Sprint retrospectives (last 3 months)
  • Incident post-mortems
  • Developer survey results
  • Static analysis reports
  • Tech lead observations

Week 2: Score and Classify

Score each item using the templates above. Assign quadrants. Get engineering leads to validate.

Week 3: Plan

  • DO NOW items: Distribute across sprints. 2-4 hours per sprint per team.
  • PLAN items: Select 1-2 for the quarter. Write RFCs. Allocate capacity.
  • CONTAIN items: Define guardrails. Write tests. Document boundaries.
  • IGNORE items: Remove from active tracking. They'll come back if they matter.

Ongoing: Monthly Check

Reassess the top 5 items monthly. Impact and risk change over time. Something in IGNORE can move to DO NOW when usage patterns shift.

The Contrarian Take

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.

Win small. Win often. Then go big.

Quick Reference Card

Print this. Put it on your wall.

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.

Sources

  1. [1]Technical Debt Quadrant · Martin Fowler
  2. [2]Technical Debt · Martin Fowler
  3. [3]Using architectural decision records to streamline decision-making during development · Amazon Web Services
  4. [4]Strangler Fig · Martin Fowler
  5. [5]Documenting Architecture Decisions · Michael Nygard, Cognitect

Checked against these sources on

Related Articles