Technical Debt

The problem of technical debt can be reduced to the central question:

How easily can the code be extended with new features?

Do you know the technical debt of your software? Feel free to contact us!


Know your Technical Debt or your software won't live long

The so-called technical debt in a software is the sum of compromises made by the developers under the pressure of tight budgets, schedules and resources. They initially represent small imperfections in the code and architecture. But without regularly implemented countermeasures they can soon become a hotspot of problems.

The most relevant long-term impact of technical debt on software technology is the question: How easily can the software continue to be modified to meet future requirements?

Technical debt in software does not all have to be given the same priority. Nor do they have to be resolved with the same priority. Developers usually don't have the time or budget to do so. To protect the teams’ innovation capacity, it is therefore recommended to always reserve a 10-20% share in the development budget for the reduction of technical debts and to use the other 80-90% of the capacity for the further development and innovation of the software.

With the Cape of Good Code Software Analysis using the DETANGLE® software, the Technical Debt is identified, localized and prioritized. For prioritization, the achievable improvements are correlated with the respective refactoring efforts required. The result is a cost-benefit matrix for the individual quality improvement measures. The team should focus on the high priority recommendations within the available quality improvement budget. If this approach becomes routine through regular analysis, the technical debt will be manageable in the long run.

New Metrics to identify the Impact of Technical Debt and locate its Root Causes

Cape of Good Code derives various innovative metrics on the location and magnitude of Technical Debt in software from the analysis results of the DETANGLE® scan. The following DETANGLE® metrics form the basis to measure the increasing "interest costs" as a consequence of rising Technical Debt:

  1. Maintenance Effort Ratio: It shows the share of maintenance effort in relation to the total development effort. A value of up to 20% would be normal. This ratio ensures that there is sufficient development capacity for value-added developments. If the maintenance share is above 20% or if the trend is going in this direction, the technical debt in the software should be urgently analyzed, localized, prioritized and subsequently reduced with DETANGLE®.

  2. Feature Effort Effectiveness Index: This metric shows whether adding new features requires more developer capacity than one would budget for. Technical debt makes it more difficult and costly to change existing code and add new features.

Figure 1:Technical Debt in relation to maintenance costs in the software life cycle.

When analyzed regularly, both metrics are meaningful indicators of whether Technical Debt is increasing in the code in a critical way.

If the level of Technical Debt becomes critical, these system level metrics can be broken down to individual code areas. This makes it possible to locate the truly risky hotspots in the code. These can then be subjected to a detailed analysis to identify the root causes in order to recommend tailored countermeasures.

Figure 2 shows the most important root causes for unstable functionality, poor performance and problematic further development of software in the left-hand listing. On the right side, further DETANGLE metrics are listed that describe the critical code areas in further detail and indicates their problem causes.

Figure 2: Causes of Technical Debt and their measurement with DETANGLE®. 

Egon Wuchner, CEO

Let's talk about your Technical Debt

Let us bring transparency to the Technical Debt of your software. Talk to me!

Good architecture quality can be more relevant than good code quality

In the case of high-quality software with the expectation of a long life cycle, good software architecture quality can be more important than good code quality. However, most analysis tools assess "only" the code quality. Our DETANGLE® metrics for architecture quality clearly correlate with the occurrence of high maintenance effort and are thus an effective indicator for architecture deficits and resulting problems for the further development of the software.

For further investigation of code quality metrics (such as cognitive complexity, code duplications, potential bugs or security vulnerabilities ), proven static code analysis tools such as Sonarqube are integrated into the DETANGLE® platform.

In the software analysis with DETANGLE® technical debt can be quantified comprehensibly as "unnecessary" additional effort for future development. This provides the development team with the necessary facts to make timely decisions about refactoring the technical problem hotspots in the software.

What are the prerequisites for a Technical Debt Analysis with DETANGLE®?

A basic prerequisite for an efficient analysis of technical debt is the use of a code repository for version management (such as Git) in software development. In this repository, individual change steps of the source code development are stored by the development teams. It thus functions as a kind of memory of the development history of the code states. DETANGLE supports in-house hosted repositories as well as all common online services, such as GitHub, GitLab and Bitbucket.

Additionally, information from a bug/issue tracker (such as Jira or AzureDevOps) and its connections to the code repository are evaluated. The use of these tools has proven to be a best practice in software engineering and is now widely used. If such tools are used, a quick configuration of DETANGLE® and an immediate execution of the analysis is possible.

If the company deviates from these best practices, a pre-analysis is required to make the database analyzable. This effort is necessary to clean up the unstructured development data and convert it into an analysis-ready format. A valuable further finding of such a pre-analysis are concrete suggestions for technical process improvement in order to modernize the development methodology through optimized use of a code repository and a bug/issue tracker.

The following parameters determine the effort and duration of the analysis:

  • Code scope (number of lines of code)
  • The history of the code (=number and extent of changes or age of the code in years)
  • Number of developers
  • Number of repositories
  • Level of detail of the root cause analysis
  • Scope of the final report/management presentation.

An analysis of Technical Debt takes between 5 and 20 days, depending on the initial situation and the customer's requirements.

What differentiates DETANGLE® from other code analysis tools?

Other software quality analysis methods often have the following limitations:

  • The focus of the quality analysis is primarily on the code, i.e. neither the architectural nor the functional perspective is examined.
  • There are too many irrelevant findings (false positives). E.g., areas of the code that have not been changed over a long period of time do not necessarily need to be improved.
  • Prioritization of findings according to effort vs. impact criteria is not possible in an automated way.

In contrast to this:

  • A DETANGLE® analysis delivers precise and holistic recommendations for the reduction of technical debt based on the analysis of the features (development effort, defect density and quality in the code).
  • Another advantage is that even features with low usage but high maintenance requirements are quickly identified and de-prioritized in the action prioritization.
  • A DETANGLE® analysis looks at the history of the code in the code repository. Through the correlation with bugs and features, more precise statements about the technical debt and its causes are made, which even allows a forecast of the effort needed to realize the recommended refactoring measures.

Locate and prioritize Technical Debt with our software analysis


Get our free whitepaper on Technical Debt now

In this white paper we illustrate why it is essential to look at Technical Debt by software analysis.

Reduce Technical Debt with the software analysis tool DETANGLE®.

The Cape of Good Code software analysis creates transparency about whether and where problematic technical debt exists in the code. In detail, Cape of Good Code provides the following services during the code analysis:

  • Determining whether and how Technical Debt is already causing increased maintenance effort. Determining and locating Technical Debt that needs to be eliminated to ensure the development of new functionality.
  • Quantifying the effort required to reduce the critical technical debt.
  • Indicating the trend of available capacity for value-added development activities vs. increased maintenance effort due to Technical Debt.
  • Using consistent KPIs as a basis for discussion for all project stakeholders so that discussions are always held using the same data. Thus, decisions can be made in a verifiable manner.
  • Improve communication in project, budget, and resource planning to account for the unavoidable effort required to reduce Technical Debt.
  • Consulting to implement appropriate processes in software development that sustainably limit the new build-up of critical technical debt.

Ask us about our offer

Are you interested in a Technical Debt Analysis with DETANGLE®? For an offer for you and your software product we need the following information:

  • Type and number of ticketing systems used
  • Type and number of repository systems used
  • Code size (number of lines of code)
  • Age of the code in years
  • No. of developers

Are you interested?