The Hidden Problem of Technical Debt
In simplified terms, technical debt is highly complicated code that is difficult and time consuming for software developers to work in. The complexity also makes it more likely for a developer to make a mistake. Just like with financial debt, a company's technical debt accrues interest payments– longer time-to-market for features, embarrassing and expensive bugs, etc..
According to a survey by McKinsey, CIOs estimate that tech debt accounts for 20-40 percent of their entire technical estate. Another study estimated that technical debt consumes 41% of large companies' IT budgets. Astonishingly, a whopping 65 percent of companies have no process to reduce their technical debt. So let's take a look at both what should be considered by a company's leadership when addressing technical debt and what KPIs developers should use to track their own progress.
High-Level Strategy for Liquidating Your Technical Debt
Technical debt is an issue that affects the entire organization through its impairment of the software value creation process. As such, it's an issue that requires the attention of more than just the developer team. Here are some key principles to keep in mind while forming your strategy to reduce technical debt.
- Technical debt is not just an IT issue. Software is an integral part of the modern corporation, often serving as the metaphorical profit engine for many companies. Likewise, technical debt affects the organization by slowing down the release of features, increasing operational costs, and resulting in defects. It's important not to just view technical debt as a problem for the IT department, but to recognize its role for the entire business.
- Transparency is necessary. The costs of technical debt must be understood both at the system- and application-level before well-founded strategy can be created. Fortunately, the Seerene platform will not only visualize areas of high tech debt and allow for drill-downs directly into the code, it also provides a Digital Boardroom with real-time KPIs for tracking the progress of software development and reduction of tech debt.
- Align the IT and business departments with a formalized decision-making process. Create a common approach for decision-making so that IT and business can work together. Change incentives for your teams to reinforce the process and so that they conform with your new technical debt strategy.
- Invest in technical debt efforts. After forming an agreed-upon strategy, dedicate resources to tackling the problem. In a waterfall approach, this may mean installing a set of software engineers responsible for managing tech debt reduction. In an agile approach, organizations may dedicate a couple developers within a team to the task.
- Tech debt reduction is an on-going process. The best solution is often to designate a portion of the IT budget for fighting technical debt. This prevents technical debt from accumulating, especially during larger projects when it might be easier to forget priorities. The other option-The quick fix of giant projects of technical debt reduction- is likely not the correct solution. It impairs the business's ability to compete during the process and can also pose a high execution risk.
- Consider a Greenfield approach. If the technical debt within an application or portfolio has accumulated to the point that it now constitutes a majority of the code, it may be worth considering scrapping the unhealthy code in favor of clean, new code as a last resort.
Applying Agile Methodology to Technical Debt Reduction
The traditional waterfall method of software development allowed for defects to occasionally slip through, which, because the testing was done at the end, would mean an increase in technical debt as developers would have redo parts of the code.
However, the iterative nature of agile methodology with it emphasis on automatic testing are much more conducive to reducing your technical debt load. By testing at the end of every sprint, you can ensure that your technical debt, bugs, and defects remain under control.
Metrics as a Tool Against Technical Debt
As mentioned above, metrics are a vital tool in both measuring and fighting your technical debt. Here are a few KPIs to consider that the Seerene platform can provide you:
- Effort in Technical Debt: This KPI measures how much of your developers' time is spent working in technical debt. This highlights the inefficiencies that might be avoided by investing in debt reduction.
- Code Coverage: This metric measures what percentage of the code has been tested. So long as it's at least 80-90%, it's considered good by most software development teams. Should it fall below 80%, this indicates more resources need to be dedicated towards test-driven development.
- Technical Debt: The amount of complex and redundant code in your software.
- Code with Frequent Defect Fixing: Measure the health of your code and identify areas of your code that require frequent defect fixing need to be remedied.
- Technical Debt Added: Track the buildup of technical debt in your code to ensure positive trends towards debt reduction.
- Bug BurnDown Chart: The bug burndown chart is used by developer and quality assurance teams to monitor progress in completing sets of bugs. It allows for an estimation of a completion date; thereby giving you an understanding of how much extra time and effort developers will need to apply in order to deliver the software.
Technical debt, like financial debt, is a nearly unavoidable aspect of doing business in the modern, digitalized economy. But similarly to financial debt, it has costs and should be managed at both a company leadership and developer level. The key for this is for management to align with the IT department on a coherent, sustainable strategy and for the developers to then implement the strategy with the help of real-time KPIs.