Risk

Technical debt, explained for founders

What engineers mean when they say technical debt, how to tell deliberate debt from neglect, and how to decide when paying it down is worth the delay to your roadmap.

3 min readBy Mayur Kale

Key takeaways

  • Technical debt is the gap between how your system is built and how it would be built if you started now with what you know. Some of it is a deliberate, sensible trade.
  • The symptom that matters is not messy code, it is estimates getting larger for similar work over time.
  • Deliberate debt taken to hit a date is fine. Debt from neglect compounds, because nobody chose it and nobody is tracking it.
  • Never approve a 'stop features and fix the code' quarter. Pay debt down inside the work that touches it.
  • Ask for a business consequence, not a code quality argument. If nobody can name one, it can wait.

Your engineers keep mentioning technical debt. You are not sure whether this is a real problem or professional grumbling, and the conversation tends to end with a request for time you cannot easily justify to a board.

Here is a way to evaluate it.

What the term means

Technical debt is the gap between how your system is built and how it would be built if you started today knowing what you now know.

Some of that gap was created deliberately, a shortcut taken to hit a launch. Some accumulated because the product changed and the code did not follow. Some is just age: libraries move on, approaches improve.

The metaphor is precise, which is why it has survived. You borrowed time in the past. You pay interest on that loan in every subsequent change, and the interest compounds.

The two kinds, and only one is a problem

Martin Fowler's distinction, deliberate versus inadvertent debt, is the most useful thing in this whole topic.

Deliberate debt is a decision. "We will hard-code this for launch and generalise it if customers actually use the feature." That is good engineering. It has been chosen, it is understood, and someone can point at it.

Inadvertent debt is accumulation. Nobody decided; the system drifted. This is the kind that hurts, because there is no record of it, no owner, and no trigger for revisiting it. You find out about it through estimates quietly getting larger.

The signal to watch

You do not need to read code to detect this. Watch estimates over time.

If work that resembles work you did a year ago now takes noticeably longer, that is the interest payment appearing in your roadmap. It is the most reliable signal available to a non-technical founder, and it is measurable from data you already have.

Supporting signals:

  • Engineers visibly reluctant to touch particular areas
  • A rising share of bugs that are regressions, things that used to work
  • Releases becoming less frequent, or more nerve-wracking
  • Onboarding a new engineer taking months rather than weeks
  • The same area appearing in incident after incident

How to decide what to fix

Ask for the business consequence. Not the code quality argument, the consequence.

Weak: "The payment module is badly structured and hard to read."

Strong: "Every change to billing takes about three times as long as it should, we have shipped four billing bugs this quarter, and the pricing change you want next month is a two-week job that should be two days."

The second is a business case. You can weigh it against other uses of the same time. The first is an aesthetic preference, and while the engineer is probably right, you have no basis on which to prioritise it.

A good engineer can always make the second argument. If nobody can, it genuinely can wait.

How to pay it down

Do not approve a dedicated quarter. "Stop features and fix the code" is almost always a mistake. It is impossible to justify externally, it expands to fill the time available, and it produces no visible progress for months. It also tends to fix the things engineers find interesting rather than the things costing you money.

Allocate a standing share instead. Ten to twenty percent of capacity, continuously. It compounds in your favour and never requires a special conversation.

Fix what you are already touching. The cheapest time to improve a piece of code is while you are in there for another reason. The context is loaded, the tests are being run anyway, and the benefit is immediate.

Prioritise by change frequency, not by ugliness. The worst code in your system, if nobody ever touches it, is costing you nothing. Mediocre code in the area you modify weekly is costing you constantly. This inverts most engineers' instincts and is nearly always the right call.

What to say in a board meeting

Not "we have technical debt". Try:

"Feature delivery in the billing area has slowed by roughly half over the last year. We are allocating fifteen percent of engineering capacity to address the cause, focused on the areas we change most. We expect delivery speed there to recover over two quarters, and we will report the estimate trend."

That is a measurable commitment with a business justification. It is also, in my experience, the conversation that actually gets approved.

Frequently asked questions

What is technical debt in simple terms?

The accumulated cost of decisions that made sense at the time but slow you down now. Shortcuts taken to hit a deadline, structure that fitted the old product but not the current one, libraries that have aged. The metaphor is apt: you borrowed time earlier and you are paying interest on it in every subsequent change.

Is technical debt always bad?

No. Deliberately taking a shortcut to hit a market window is often the correct commercial decision, and refusing to ever take one is its own failure mode. What distinguishes healthy debt from unhealthy is whether it was chosen knowingly, written down, and revisited. Debt nobody decided to take is the dangerous kind, because nobody is tracking the interest.

How do I know if we have too much technical debt?

Look at estimates over time for comparable work. If a change that would have taken three days last year now takes two weeks, that is the interest payment showing up. Other signals: fear of touching certain areas, a rising proportion of bugs that are regressions, and a slowdown in how often you can release.

Should we stop building features to fix technical debt?

Almost never as a dedicated period. A quarter with no user-visible progress is very hard to justify and tends to expand. Better to allocate a standing share of capacity, commonly ten to twenty percent, and to pay down debt in the specific areas you are already touching, where the cost is lowest and the benefit is immediate.

How do I evaluate an engineer's request to refactor something?

Ask for the business consequence. 'This code is ugly' is not one. 'Every change to billing takes three times longer than it should, and we have shipped four billing bugs this quarter' is. If nobody can articulate a cost you recognise, it can wait, and a good engineer will be able to articulate it.

References & further reading

  1. [1]
  2. [2]
  3. [3]

Turn the trend into shipped software

I contract as a senior fullstack and data engineer, building the production systems your customers and your reporting depend on.

Explore services↗