Software Analysis

Cape of Good Code has developed DETANGLE®, a software suite to analyze software and locate and measure Technical Debt and knowledge distribution issues in R&D projects.

  • Identify the Technical Debt that really endangers the future of your software.
  • Know the effort required to get the Technical Debt under control
  • Locate all code and architecture quality issues to efficiently counteract it
  • Examine the organization as a cause for quality problems
  • Maintain the ability to innovate by limiting maintenance effort 

Why to analyze software?

The development of a software is a knowledge-based process, using appropriate technologies and experts. For an error-free quality of the final result, technology, know-how, processes and methods must complement each other in an ideal way.

In practice, this will not be the case. Thus, every software has weak points, which usually grow in the course of its life cycle. Where these weak points are and how critical they already are or can become, is shown by a software analysis.

Software analyses are important for everyone who either creates software or wants to acquire a software company. Regular analyses of the software in the development process have become a standard part of quality management in many software companies.

In the case of M&A transactions, investors increasingly uses a special software due diligence in the due diligence process. This gives them certainty that the software technology of the target company will still have a long life at normal costs.

A software analysis assesses the technical realization of the software. The technical quality of a software can be measured in a largely automated way with our DETANGLE Analysis Suite. Since the quality of a software is inseparable from the quality of the development processes and methods, these are also analyzed by our consultants in the same software analysis.

  • The topics examined by Cape of Good Code in a software analysis can be:
  • The development methods and test routines
  • The knowledge distribution in the team
  • Service and maintenance processes
  • Scope and handling of technical debt

When do quality issues cause the end of your software?

Every software has weaknesses in its technology and architecture. These problems accumulate over the years and become a threat to the life-cycle of the software. The metaphor "technical debt" is used to describe these cumulative liabilities. This debt drastically limits the future ability to further develop the software.

More than 20% software maintenance cost (analogy: interest and amortization for financial debt) is a good indication for a problematic level of technical debt, as it absorbs too much of the R&D capacity that is needed for ongoing development.

Time pressure, budget pressure and an overload of individual software developers are the triggers for these quality problems. By these aforementioned factors developers are tempted to enter consciously or unconsciously critical technical compromises. Without timely countermeasures, these compromises accumulate to critical technical debt. These will continue to increase with each new feature or interation until a turnaround can only be initiated with so much effort that it no longer makes economic sense. This usually ends the useful life cycle of a software unnecessarily early.

How far away is your software from this point of no return?

This is the question that every software producer has to ask himself frequently. Cape of Good Code helps you to answer this question with our software analyses. To do so, we analyze your software with the DETANGLE® Analysis Suite and show you in detail how you can reduce the technical debt and get back into the technological green zone. This will keep your software competitive in the long term.

Egon Wuchner, CEO

Contact me and we will work out your individual software analysis.

Every software analysis project is unique and presents different challenges. We always have your company in mind and develop solutions that suit you.

What should I know about Technical Debt?

Developing a software is a "never-ending story". The need for updates or extensions is present throughout the entire software lifecycle. In that process, new technical debts always arise. If they are not routinely reduced, the maintenance effort rises far above the critical mark of 20% of the total development capacity. The value is an indicator that the team is increasingly busy with the negative effects of the debts instead of developing new features.

How to locate and quantify the technical debt in code and architecture in order to take effective countermeasures in time?

It is important to know:

  • Not every technical debt is a pressing problem.
  • Not every critical technical debt is easy to identify.
  • Technical debt in the software architecture can be particularly problematic.

In order to meet the recommended budget of 20% development capacity for maintenance and debt reduction, critical debt should be kept always in mind during development. But the question remains - how do I identify debt and how can I then prioritise the really critical debts in the countermeasures to make the most efficient use of the always scarce development capacity?


Learn more about Software Analysis


Get our free white paper on Technical Debt now

In this white paper we illustrate why it is essential to look at technical debt in a software analysis.

Is it possible to analyse software quality in an automated way?

Cape of Good Code has developed the DETANGLE® software suite for the analysis of the software code and architecture.

The unique feature of the DETANGLE® platform is that not only the established code quality tools can be integrated to support identification of technical debt in the code, but additionally the debt in the software architecture can also be evaluated due to our highly innovative algorithms. Thus, for the first time in software analysis, technical debt gets analysed both in the code and in the architecture.

The algorithms also allow the impact of different technical development procedures to be quantified and correlated with the maintenance and additional costs in the development. New and more specific KPIs allow monitoring of trends in the most critical debts. This significantly improves the control and sustainability of debt reduction measures.

The Cape of Good Code Software Analysis with DETANGLE® includes the following services:

  • Localisation of Technical Debt in the code and architecture.
  • Checking the efficiency of the technical development processes (such as testing, review activities) and the completeness of the documentation.
  • Forecasting the impact on maintenance costs and on the future extensibility of the software.
  • Prioritise the measures to reduce the debt with effort-vs-benefit criteria.
  • Tracing the technical debts to their actual technical causes (e.g. architecture or code quality as well as quality of the development processes). 

We support the stakeholders in software development with professional analyses to keep the maintenance effort in the lifecycle of the software within a reasonable corridor of change and stability. The DETANGLE® Classic Analysis provides all needed data for code restructuring in order to reduce the technical debt in the software to a non-critical level in a targeted and effective manner. In the DETANGLE® Pro version, the system even makes automatic suggestions for restructuring solutions to architects and developers.

Based on the results of the analysis with the DETANGLE® Analysis Suite and supported by information and details from interviews and documents, many useful insights support all stakeholders in your software development process.


Findings for the stakeholders

Project Manager, Product Owner

  • Overview of whether maintenance efforts exceed critical thresholds. Identifiable by the proportion of maintenance effort vs. total development capacity.
  • Identification of debt hotspots.  Effort estimation to reduce the technical debt in these hotspots and to fix the causes. Guidance on prioritisation based on cost-benefit considerations.
  • Guidance on planning budgets for developing new features vs. paying off critical Technical Debt. This will enable a long-term balance of stability and innovation

Technical Manager, Software Architect

  • Valid statements on a variety of potential causes of Technical Debt facilitate prioritisation of countermeasures. Important aspects are:
    • Extensibility of the code architecture
    • Maintainability of the code
    • Extent of documentation gaps
    • Extent of test code or test coverage
    • Efficiency of the development teams
    • Effectiveness of review activities
    • Quality of technical processes (application of best practices)

Startup Founder, R&D Manager, CTO, COO

  • Essential performance metrics across the product landscape enable identification of best practices for software development and software architecture.  
  • Data-based decision support to prioritise capacity for innovation vs. paying off technical debt across diverse development teams and products.
  • Analysis of software quality and scalability as well as software engineering processes to prepare for an investor round.

When is the right time to analyse your software?

Symptoms caused by technical debt are many and start early. So you could recognise them in time. Examples of indications are:

  • Decreasing innovation momentum
  • Increasing number of bugs and decreasing stability
  • Lengthy testing, time-consuming troubleshooting
  • Increased efforts for the integration of new features
  • Increasing maintenance cost
  • Regularly missed launch dates
  • Decreasing customer satisfaction
  • Demotivated developers, fluctuation

Developing software without knowing the technical debt is like driving in the fog at full speed. To arrive at the destination safely you need luck. We support you with tools, expertise and experience to not base the quality of your software on luck. Get in touch with us.

In software projects, there are inevitable gaps and ambiguities in the specifications at the beginning of the project. Every software project therefore undergoes constant conceptual and technological changes, usually without adjusting schedules and budgets. The many small inadequacies, bugs, best practice violations, workarounds and quick fixes that occur from sprint to sprint or update to update quickly add up to a problematic level of technical debt if no sufficient countermeasures are taken.

The Cape of Good Code team can support you in analysing Technical Debt in code and architecture at a very early stage of development. Through a software scan with DETANGLE® and some structured interviews, the hotspots of debt are identified with reasonable effort.

For the identified hotspots of debt, a roadmap for improving code, architecture and the technical development processes is worked out, taking into account the budget and capacity constraints at hand. At the same time, it also raises awareness among developers and project managers to use best practices and reduce debt on a regular basis. 

Questions that every software developer or project manager should ask themselves regularly

  • What is the nature of my technical debt? Do they arise from problems in the architecture, poor code quality, lack of documentation and inadequate testing, or a mixture of all?
  • What is the distribution of technical debt in the code base? Where are the hotspots of technical debt found? Are there any patterns?
  • How can I estimate the correction effort?
  • How do I identify the respective risk potential of the localised Technical Debt?
  • How can the measures to reduce technical debt be prioritised according to the best cost/benefit ratio?
  • How can best practices of software engineering be sustainably anchored in the team?
If managers and employees in software development deal with these questions regularly, the problem of growing technical debt should be controllable. Regularly is the key word, as new technical debt can easily arise and escalate at any time. We therefore recommend making the measurement and reduction of Technical Debt a regular routine.

What fields of investigation does our software analysis cover?

Cape of Good Code provides services and analysis by developers for developers. We understand from our own experience the underlying conditions in software development. This is exactly why we have developed DETANGLE®. We offer the three service packages "Health Check", "Improvement" and "Restructuring", which differ in the scope of the analysis fields and methods (such as the DETANGLE® Classic or DETANGLE® Pro version, interviews and consulting).

Our analyses and proposals are characterised by a high level of analytical depth, but also by pragmatism and implementability. And the effort required for our analysis of your software is less than you probably would expect.

  • Health Check

  • Improvement

  • Restructuring

Health Check


Get a quick overview of development efforts and software quality




Get a detailed picture of the software and your improvement options




Get full transparency of your software and recommendations for refactoring/restructuring

Classification of R&D efforts
High-level software quality analysis
Code quality
Architecture quality
Team efficiency
Technical development processes
Documentation gaps
Technical Debt: risk potential vs. effort
DevOps maturity
Cloud readiness
(Cloud) scalability
Automated refactoring suggestions
API Design
Performance monitoring
Feature usage
Side-effect analysis of (non) safety-relevant features

What's next after the software analysis?

According to the scope and risk potential of the quality issues, an improvement project should be initiated timely. It is essential that enough capacity of qualified developers is made available for this task. We recommend adding a dedicated workstream for organisational measures to the project, to keep the future build-up of technical weaknesses (e.g. Technical Debt) under control.  

In your software quality improvement project, Cape of Good Code can support by implementing the results and recommendations of the analysis. The DETANGLE® Pro version is used for automated refactoring suggestions to evaluate different options together with the developers. Initial experience shows that this can save up to 50% of the time needed to develop a solution.

In detail, Cape of Good Code offers the following services:

  • Management of the project to ensure consistent implementation of the recommendations.
  • Recording of refactoring measures as issues including description and rationale.
  • Training of the development teams on best practices in dealing with issue trackers and code repositories.
  • Train the development teams on best practices for designing code for testability.
  • Conceptual advice if a major transformation of the code architecture is required.

We also support the regular execution of these analyses, i.e. at least once per release.

This way, the effect of the measures is proven and new negative trends are identified and limited at an early stage. In this way, even after the initial and extensive software analysis, it is possible to keep the ever-present technical debt under control in the long term. 

Are you interested?


Our Latest Knowledge Articles

In our knowledge blog you will constantly find new articles on various topics from software development.

You can find more articles in our knowledge area