Technical debt is one of the few engineering terms that non-engineers immediately grasp, which is both its strength and the reason it gets misused. Used precisely it is the most effective way to explain why a team is slowing down. Used loosely it becomes a label for any code somebody dislikes.

The Metaphor, Stated Properly

The original idea is specific. You take a shortcut to ship sooner — the principal. From then on, every change in that area costs more than it should — the interest. You can repay the principal by going back and doing it properly, or keep paying interest indefinitely.

Two implications follow, and both are routinely missed.

First, debt can be a good decision. Shipping six weeks earlier to win a customer may be worth years of mild interest. Businesses borrow deliberately all the time.

Second, interest compounds. A shortcut other code is built on top of becomes more expensive to unwind each time something new depends on it. Debt left alone does not stay the same size.

Where the metaphor breaks down

Unlike a bank loan, you cannot see the balance, the rate is unknown, and interest is charged only when you touch that area. Debt in code nobody ever modifies costs nothing at all — which is why "clean it all up" is poor advice and "clean up what we keep changing" is good advice.

Four Kinds, and Why the Difference Matters

DeliberateAccidental
Prudent "We ship now and fix the data model next quarter." Recorded, scheduled, defensible. "Now that it is built, we see how it should have been done." Unavoidable, and how learning looks.
Reckless "No time for design." A choice to skip thinking, not a trade. "What is a data model?" Not debt — a skills gap.

The bottom-right box is the one worth being honest about internally. Calling plain carelessness "technical debt" dignifies it, and makes the genuine cases harder to argue for later.

Recognising the Interest Payments

You rarely see debt directly. You see its symptoms:

  • Estimates inflate for one area. The same size of change takes three times longer in a particular module, and everyone knows which one.
  • Fixes cause new breakages. Tight coupling means nothing can be changed in isolation.
  • Only one person will touch it. A single point of knowledge is a business risk wearing an engineering costume.
  • Incidents cluster. Most production problems trace to the same few places.
  • Onboarding is slow. New engineers take months because the system cannot be reasoned about.
  • Testing is manual because the code cannot be tested automatically.

Each of these converts into a number — hours, incidents, delay — and numbers are what make the case.

Making the Argument

Engineers lose this conversation by holding it in engineering terms. "The code is a mess" is an aesthetic claim and gets treated as one.

What works:

  1. Translate into business cost. "Changes to billing take three weeks instead of one, and billing caused most of last quarter's incidents."
  2. Attach it to something already hurting. A missed date, a customer escalation, an outage. Abstract risk does not get funded; a problem the business already feels does.
  3. Propose something bounded. "Four weeks to separate these two modules, after which billing changes return to normal speed." Not "we need to refactor".
  4. Offer a measurable outcome — lead time for changes in that area, incident count, onboarding time.
  5. Be honest about what you will not fix. Proposing to clean everything signals poor judgement; targeting the parts under active change signals the opposite.

Paying It Down Without Stopping

  • Clean what you touch. Leave each area slightly better than you found it. Over a year this handles a surprising amount with no separate budget.
  • Reserve a fixed share of capacity — a consistent slice of every cycle beats an occasional cleanup sprint that gets cancelled when something urgent appears.
  • Replace incrementally, never rewrite. Route new work through a clean implementation and migrate the old path gradually.
  • Write the debt down when you take it. A short note on what was skipped and why is worth more later than anyone expects.
  • Add a test before you change anything. It is the only way to know you have not broken behaviour nobody documented.

The same economics decide whether to keep extending a system at all — our guide to build versus buy covers when accumulated debt makes replacement the cheaper option.

Key Takeaways

  • Debt is a deliberate shortcut with interest on every later change — not a synonym for bad code.
  • Interest compounds, and it is only charged on code you actually touch.
  • Argue in delivery time and incidents, not in code quality.
  • Propose bounded work with a measurable outcome; never an open-ended rewrite.
  • A fixed share of every cycle beats a cleanup sprint that gets cancelled.

Written by the WritePures newsroom. Spotted something that needs updating? Tell our editors.