Over a million developers have joined DZone.

The 3 Secret Types of Technical Debt

DZone's Guide to

The 3 Secret Types of Technical Debt

Check out the three categories of technical debt to find out which one you fit into and which one you want.

· Agile Zone ·
Free Resource

Engineers build business. See why software teams at Atlassian, PayPal, TripAdvisor, Adobe, and more use GitPrime to be more data-driven. Request a demo today.

I have noticed a pattern on the projects I have worked on. Technical debt develops in three common categories. The interest you will be paying on that debt looks very different between those cases.

1. Eventually Repaid

Some teams never allow technical debt to grow to levels where they even talk about technical debt. It's just business, as usual, to refactor on daily basis.

Other teams may start with a noticeable level of technical debt because they are taking on work on legacy systems, but they reduce it as they go along by refactoring while adding new features.

The amount of interest you pay on technical debt is eventually so low, you barely notice it.

2. Sustainable

Teams add new features but refactor the code as they go along and the technical debt stays more or less at the same level.

This means that even though there is noticeable technical debt present in the code, the team can deliver features at a sustainable peace.

So, they are continually repaying the interest on the technical debt, but the amount of the debt stays the same. The difference between “eventually repaid” and “sustainable” is the amount of interest you pay on a daily basis while making changes to the code. In “eventually repaid” the interest gets close to zero, in “sustainable” it stays at a constant level throughout the lifecycle of the project.

3. Compound Growth

Teams stop refactoring but continue to add new features. Teams stop paying interest on the debt, and the interest is consolidated into the debt. The debt goes into a compound interest cycle and starts growing exponentially.

Similar to the Broken Windows Theory, just applied to quality of code, if you see that non-paying technical debt is the norm in your team, you personally don't repay it either, just add new features and the debt grows.

This typically ends with postponed releases, bugs in production and a lot of tension in meetings where people blame each other for not working well or hard enough. It takes several postponed releases and a few major bugs with visibility in high management levels to realize the teams need to repay some debt to go faster.

Unfortunately, the cost of repaying debt is much higher by that point, just because of the compound interest you have to pay back that was consolidated into the debt. In other words, 2 hours invested in repaying technical debt 6 months ago, could be equivalent to 1 day of work today to repay the same amount of debt.

The problem with this type of approach is it feels you are going fast to start with because you are delivering features and the technical debt is not hurting you as much at the very beginning. The problem is you are putting yourself on the compound interest curve, instead of staying linear. Linear and compound curves look similar at the start, very different later on.

In most cases, you want to avoid ending up in this category. An example of where this type of debt is acceptable is when you need to hit a regulatory deadline, where the cost of not hitting the deadline outweighs the cost of repaying the compound debt accumulated later on.

What Is the Lesson Learned Here?

Keep in mind which category you want to be in and make the conscious choice to invest in technical excellence where necessary. Aim for low levels of technical debt or constant medium levels, and rarely compound growth of debt.

Eventually Repaid


Compound growth

Type of debt.

You eventually repay almost all debt.

You keep debt at the same level by paying off all the interest.

You do not repay debt and interest is added to the debt and debt grows exponentially.

Daily repayment amount

Develop features and refactor the new and old code heavily.

Develop features and refactor the new and old code a bit.

Only developing new features with little to no refactoring.

Daily interest teams pay

Linear, going down.

For example, at first developers are going 24% slower because of debt, eventually, 0% slower if they repaid all of the debt.

Linear, constant.

For example, developers are constantly 12% slower because of the debt.

Grows exponentially

For example, developers are 22% slower initially but in 12 months time, they are 370% slower compared to if they had no technical debt.

Next Steps

At Traffic Parrot, we are building a framework to help teams visualize, manage, and reduce technical debt. It will help you decide on the level of technical debt that is acceptable and make the right choices at the right time so that you do not end up in the “compound growth” category. Sign up here to get notified when it's available.

What is your experience with technical debt?

Engineers build business. See why software teams at Atlassian, PayPal, TripAdvisor, Adobe, and more use GitPrime to be more data-driven. Request a demo today.

technical debt ,technical debt elimination ,refactoring ,delivery ,agile anti patterns ,digital transformation ,sustainable pace

Opinions expressed by DZone contributors are their own.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}