Skip to content

Why Technical Debt Tracking Tools Fail

Make technical debt tracking tools useful with named owners, a debt register and a few measures connected to delivery, incidents and business decisions.

7 min read
Conceptual unused tracking gadgets behind a simple notebook and practical repair tool.
On this page

I've evaluated or deployed 8 different technical debt tracking tools over the past 5 years. SonarQube, CodeClimate, CodeScene, Stepsize, custom Jira workflows, spreadsheets, Notion databases, and a homegrown dashboard. Most failed. Not because the tools were bad, but because the approach was wrong.

Here's my confession: the tool I got the most value from was a Google Sheet. And the most expensive tool we deployed was the one that did the least for us. That mismatch taught me that technical debt tracking is a people problem dressed up as a tooling problem.

Why Tools Fail: The Five Patterns

Failure points to check Unread dashboard Backlog black hole Measurement obsession Tool without process Engineering only
Figure 1. A dashboard or register needs a named review process and a route into delivery decisions.

Pattern 1: The Dashboard Nobody Watches

We deployed SonarQube in 2022. Beautiful dashboards. Every file rated A through E. Total "technical debt" measured in days of remediation effort. The first week, everyone looked at it. The second week, half the team checked. By month two, nobody opened it unless I asked in a meeting.

SonarQube defines technical debt as estimated remediation effort for detected maintainability issues. That estimate needs the context of change difficulty, incidents and product priorities before it can guide a business decision.[1]

The fix: Use the technical debt guide to connect measurement to decisions. Don't track quality metrics in isolation. Connect every metric to a business outcome. "427 code smells" means nothing. "These 12 code smells in the payments module contributed to 3 incidents last quarter and added an estimated 40 hours of development overhead" is actionable.[2]

Pattern 2: The Backlog Black Hole

The most common approach: create tech debt tickets in Jira and put them in the backlog. Then never prioritize them because feature work always wins.

I tracked this at one company. Over 18 months, the team created 147 tech debt tickets. They completed 23. The average age of an open tech debt ticket was 7 months. By the time anyone looked at the older tickets, the codebase had changed so much that the tickets were irrelevant. Pure waste.

The fix: Record debt ownership and decisions in a debt register, and make the work visible in normal capacity planning. A separate review can help prioritisation, but selected debt work still competes for the same delivery capacity as feature work.[3]

Pattern 3: The Measurement Obsession

One team I worked with spent 3 months building a custom debt tracking dashboard. It pulled data from Git, SonarQube, Jira, and PagerDuty. It had 14 charts and 6 aggregate scores. It was beautiful.

It changed nothing. The team spent so much time building and maintaining the measurement system that they had less time to actually fix debt. They'd perfected the art of watching the problem grow in high definition.

The fix: Track 3 metrics maximum. I recommend: (1) developer velocity delta (how much time is lost to debt), (2) incident density by module, and (3) change lead time for high-debt areas. If you can track only one, track velocity delta.

The SPACE framework explains why a full view of developer productivity needs multiple dimensions. Treat this initial metric as a starting point for discussion.[4]

Pattern 4: The Tool Without Process

Tools need process. Process doesn't need tools.

I've seen teams deploy CodeScene (an excellent tool) without establishing who reviews the data, when they review it, or what actions they take based on the findings. The tool generates insights. Nobody consumes them.

The fix: Before choosing a tool, define:

  • Who reviews debt data? (Name the person.)
  • When do they review it? (Put it on the calendar.)
  • What decisions does the data inform? (Sprint planning? Quarterly OKRs? Architecture reviews?)
  • What thresholds trigger action? (If metric X exceeds Y, we do Z.)

If you can't answer these four questions, don't buy a tool. You'll waste the money.

Pattern 5: The Engineering-Only Initiative

Every failed debt tracking effort I've seen was owned entirely by engineering. When debt tracking is an engineering-only initiative, it's the first thing cut when deadlines get tight. And deadlines always get tight.

The fix: Make debt tracking visible to product and leadership. Include a "debt health" section in your monthly business review. When the VP of Product sees that the payments module has a 28% change failure rate, they'll think twice before asking for another payment feature without remediation.

What Actually Works

After all these failures, here's the system that stuck.

The Debt Register (Not a Backlog)

A simple document (spreadsheet, Notion, whatever your team actually uses) with these columns:

Item Owner Impact Score Risk Score Quadrant Status Last Review
Payment processor coupling Sarah 8 7 PLAN RFC drafted Mar 1
Missing auth tests Mike 7 2 DO NOW In progress Mar 1
Legacy CSS build - 2 4 IGNORE - Mar 1

This isn't a backlog. It's a decision-making document. Each item has a quadrant assignment (from the prioritisation framework) and a clear status.

The Monthly Review Ritual

Turn the register into decisions Review impact Check thresholds Review progress Adjust priorities
Figure 2. Use the review to decide which work gets capacity and how the result will be checked.

First Monday of every month, 30 minutes. Attendees: engineering lead, product lead, one exec sponsor.

Agenda:

  1. Review top 5 items by impact (5 min)
  2. Review any threshold breaches (5 min)
  3. Review remediation progress (5 min)
  4. Adjust priorities for next month (10 min)
  5. Decide on any new items to add (5 min)

This meeting is the highest-value 30 minutes I spend each month. It keeps debt visible, keeps it connected to business priorities, and gives engineering a regular forum to raise concerns with stakeholder support.

The Lightweight Metrics

The debt metrics guide explains the definitions. Review the measures monthly and track their trends.[5]

DEBT HEALTH DASHBOARD (Monthly)

1. Developer Velocity Delta
   Target: >80% | Current: 72% | Trend: Stable
   (% of engineering time on productive work vs. debt workarounds)

2. Incident Density (debt-related)
   Target: <0.10 | Current: 0.18 | Trend: Improving (was 0.24)
   (debt-related incidents per deployment)

3. Change Lead Time (high-debt modules)
   Target: <2x baseline | Current: 2.4x | Trend: Stable
   (how much longer changes take in debt-heavy areas)

That's it. Three numbers. Reviewed monthly. Connected to decisions.

The Tool Evaluation Checklist

If you do decide to buy a tool, evaluate it against these criteria:

  • Does it connect code metrics to business outcomes (delivery speed, incidents)?
  • Does it integrate with your existing workflow (IDE, CI/CD, Jira/Linear)?
  • Can a non-engineer understand its outputs?
  • Does it require less than 1 hour/month of maintenance?
  • Does it surface trends, not just snapshots?
  • Can it answer "what should we fix next?" not just "what's broken?"

If a tool checks all six boxes, consider it. If it doesn't, a spreadsheet will serve you better.

The Contrarian Take

The technical debt tracking industry sells you a comforting lie: that the right tool will solve your debt problem. It won't. Tools measure. People decide. If your organization doesn't have the process, the stakeholder alignment, and the cultural commitment to act on debt data, no tool will change that.

I was wrong about this for years. I kept thinking the next tool would be the one that finally made tech debt management "click." CodeClimate would replace SonarQube and everything would work. CodeScene would replace CodeClimate and everything would work.

What actually worked was a spreadsheet, a monthly meeting, and a VP of Product who cared. Total cost: $0 in tooling, 30 minutes per month, and one relationship that took effort to build.

Stop shopping for tools. Start building the process. The spreadsheet is fine.

Frequently asked questions

Is a technical debt register different from a backlog?

The register described here records ownership, impact, risk and the latest decision about a debt item. It can coexist with delivery tickets, provided the team has a review cadence and the decision about funded work reaches its normal planning process.

What does SonarQube's technical debt number measure?

SonarQube documents a sum of estimated remediation effort for maintainability issues detected by its rules. Treat that estimate as one input alongside system behaviour and change difficulty when deciding which work matters to the business.

Which measures should a small team start tracking?

Choose a small set the team can maintain and act on, such as time lost to workarounds, incidents in a component and change lead time. Use consistent definitions and discuss the trend alongside the work that might explain it.

When is a spreadsheet enough for debt tracking?

A spreadsheet can be enough while the register is small and the review process is maintained. Add specialised tooling when it answers a specific recurring question or reduces collection work enough to justify its setup and ongoing maintenance.

Sources

  1. [1]Understanding measures and metrics | SonarQube Server 2026.1 LTA | Sonar Documentation · SonarSource
  2. [2]bliki: Technical Debt · Martin Fowler
  3. [3]DORA | Capabilities: Work in process limits · DORA
  4. [4]The SPACE of Developer Productivity: There's more to it than you think - Microsoft Research · Microsoft Research
  5. [5]DORA | DORA’s software delivery performance metrics · DORA

Checked against these sources on

Related Articles