If you’re in the software industry, the concept of technical debt will come up at some point. Agile software development’s popularity has spread this concept to teams who aren’t actively practicing Agile methodologies. Unlike the financial debt it was named after, technical debt isn’t characteristically bad and can be useful at times. However, too much can be debilitating to an organization. Here’s how technical debt affects products, development teams, organizations, and customers.
What is Technical Debt?
The term was first coined as a metaphor in the early ’90s to describe the consequences of choosing simple or easy solutions over more complex, long-term solutions to save time. The choice to take the quicker path is not in itself bad; it can be used to ensure you’ve got a working product that meets deadlines. However, the time saved will accumulate interest in the form of increased development effort as the project moves forward. As Ward Cunningham put it in his original 1992 paper,
“A little debt speeds development so long as it is paid back promptly with a rewrite. Objects make the cost of this transaction tolerable. The danger occurs when the debt is not repaid. Every minute spent on not-quite-right code counts as interest on that debt. Entire engineering organizations can be brought to a stand-still under the debt load of an unconsolidated implementation, object-oriented or otherwise.”
How is it Created?
Technical debt is created when development teams prioritize speed and expedited delivery over quality and best practices. A typical example of this is when teams rush coding solutions to meet sprint deadlines, resulting in long methods, inefficient functions, or messy code. Another example is the consistent focus on developing new features over fixing bugs, refactoring the application, or creating thorough and up-to-date documentation. This focus is especially detrimental when onboarding new developers because they won’t understand previously made decisions or their reasoning.
The Costs Can Be Significant
Delivered Value Declines
As technical debt increases, so does the effort required to maintain the project’s forward momentum. The reasons for this increased effort can take many forms: high code complexity, significant manual testing requirements, creating workarounds for software limitations, etc.Reduced productivity tends to indicate the team members may be slowing down. In reality, they are working hard and producing good work. However, a significant portion is now focused on addressing issues resulting from technical debt. The result is less time for your team to develop new features that provide value to the client.
Product Defects Increase
A typical result of technical debt is the increase in defects that make it into the delivered product, impacting the customer experience and delivering negative value. The product’s maintenance costs increase over its lifetime and intensify the workload on other operational areas, such as dedicated support staff.
These could easily have been grouped under declining delivered value, as the team will be required to expend effort addressing these defects that could have been spent developing new features. However, it’s important to note that their effects can be felt beyond the development team.
Transparency is Reduced
As technical debt increases, it becomes much harder to understand the current state of the system and the effort required to implement new features. My team experienced a perfect example of this on a project towards the end of last year. What was initially expected to be a simple UI change dramatically increased in scope due to the decision to hardcode various values made earlier in the project.
Job Satisfaction Wanes
In addition to the more tangible effects of technical debt, it also has a serious impact on your software development team’s morale. Developers are stuck working with a flawed system and completing a large amount of manual work. The simple UI change mentioned above resulted in a multi-sprint feature that took weeks to complete. The impact of this can be felt both internally and externally as team members and business stakeholders become frustrated with the time it takes to complete seemingly small tasks.
Weak Foundations for Future Development
When the time comes to replace the application or pieces of functionality, the technical debt is often used for reference. Business logic might be copied from the existing application, and unknown business requirements are reverse engineered to save time. Building upon a system with unclear logic and requirements will only result in an unstable foundation for future development efforts.
Loss of Opportunity
One of the highest costs of technical debt is the loss of opportunity that comes with it. Your team will have to spend most of their time focusing on operational tasks and won’t have time to focus on being strategic or innovating.
While technical debt does have significant long-term costs, it doesn’t have to be a negative phenomenon. When planned and undertaken with caution, it can bring quick business value for a company. However, technical debt is not profitable in the long run for the reasons mentioned above. At DragonSpears, we hold ourselves accountable by making the restitution of technical debt part of our normal development process.