Cost of technical debt

The team talks about technical debt, and the business can’t see its cost

When the business can’t see what technical debt costs, that is a symptom, and its causes sit in three places: in the numbers the business reads, where debt doesn’t appear; in the team’s list, where everything is called debt; and in code without tests, where every shortcut adds more debt. The three reinforce one another, and refactoring slips from quarter to quarter.

Book a call

Does this sound familiar?

  • Every time the team asks for time on technical debt, the request loses to the next feature.
  • On the parts of the code everyone knows are fragile, estimates keep growing, and the extra margin is now taken for granted.
  • Workarounds have piled up until they became the normal way of making changes.
  • Discussions about what to refactor end in opposing opinions, because nobody has an estimate of what each part costs.
  • We have a static analysis report full of findings, and it is unclear which to start with.

Why does the cost of debt stay invisible?

The business sees the last link in the chain, the postponed refactoring, which arrives as a request for time. The other causes feed it from earlier on, and the costliest one to ignore is the lack of priorities, because without a priority you can’t even measure the debt.

  1. No number shows the debt

    It has no ticket, no deadline and no place in the metrics the business reads, so it surfaces only as a complaint from the team. Until it is linked to the changes it slows down, it remains a cost you pay without seeing it.

  2. Everything is called debt, and nothing has a priority

    When old code, stalled libraries and choices people dislike end up in the same list, the request for time looks bottomless. Some of the debt can stay where it is, and separating it from the part that holds back the roadmap is what makes the request credible.

  3. Refactoring gets pushed to next quarter

    Without a clear priority every deadline beats debt, and every shortcut taken to meet it adds more. By the time it is finally discussed, the work has become a project too big to fund, when it could be done one piece at a time inside the stories that deliver features.

  4. The tests that make a change safe are missing

    Where tests don’t describe the behaviour of the code, touching it is a risk, and the team avoids those parts. Debt grows as a result, because even new code gets built around the parts nobody dares to change.

What changes when debt has a cost everyone can see

The team brings the business a few precise areas, each with the roadmap changes it slows down and an action beside it, including the option of leaving it as it is, and the discussion starts from there. There is a sequence of work to weigh up.

The people who steer the product plan with the features that pass through fragile areas in front of them, and put the refactoring of those areas inside the stories that touch them. The team estimates those parts by the same yardstick as the others, because it knows which are fragile and which hold.

Let’s start where debt costs you

In the call we look at which roadmap changes the debt slows down, and tell you plainly whether you need a Technical Debt Assessment or whether less will do.

We use your data to respond to your request. Read our Privacy Policy.