Summary: Technical debt comes up when a software project gets delayed in development, and it will arise with shortcuts in the delivery flow. When developers prioritize speedy delivery over perfection in the code, we face ‘technical debt’ in software development. In the writeup below, we analyze what technical debt is and how to address & resolve it.
What is Technical Debt?
Ward Cunningham, the author of ‘Agile Manifesto‘ and the man who invented Wiki, gave the financial loan simile to understand the concept better.
“With borrowed money, you can do something sooner than you might otherwise, but then until you pay back that money, you’ll be paying interest. I thought borrowing money was a good idea, I thought that rushing software out the door to get some experience with it was a good idea, but that, of course, you would eventually go back, and as you learned things about that software, you would repay that loan by refactoring the program to reflect your experience as you acquired it.”
Gartner defines technical debt as the “deviation of a system from any of its non-functional requirements.” The more the analysis, the more the term variations – actual or metaphorical -. Read ahead to get a clear picture of what technical debt in software development is all about.
Let us see this in our minds – Technical Debt is intentional; it is not a “mistake” or an accidental lousy code. It is not a slip that happens inadvertently – it is a deliberate shortcut taken for some present advantage while risking the future. It is a tool or strategy used in the present to get ahead – it is a conscious loan being taken to meet current demand or need, knowing fully well that the future could involve costs and the interest on the loan. It is, in fact, a principal cost plus interest.
“Technical debt describes the consequences of software development actions that intentionally or unintentionally prioritize client value and/or project constraints such as delivery deadlines, over more technical implementation, and design considerations.”
As the particular project matures and progresses, the TD incurred will decrease the project’s agility. Therefore, it becomes imperative to address it and tackle it.
Technical debt is similar to postponing paying your monthly bills. By doing so, the bill amount keeps adding up along with interest due to exceeding due dates. So, paying your account after six months makes it challenging to repay.
Technical debt consumes 40% of development time and results in higher operational expenses.
We respect your privacy. Your information is safe.
An Example of Technical Debt
You send the developed user story to the Agile testing team for review. Now, there are two scenarios at play:
- The testing team reports some bugs concerning the developed feature, and your team ignores those fixtures and moves ahead with the following user story in the queue. Thus, it results in technical debt, the extra cost of fixing over-layered bugs in one go later.
- The Agile team approves the feature. It is integrated, delivered, and deployed into the live environment. Sometime later, when a change is required, it becomes challenging for developers to append the new code to the original. Thus, resulting in technical debt.
Or consider a case when developers make an eCommerce website on WordPress because they prefer the CMS platform and its ease of working. Traffic is high on that website, the existing system cannot handle it, the website faces cart abandonment issues, and finally, the only solution is to migrate the website to a more suitable eCommerce platform.
Few other examples of Technical Debt are code complexities, integration test failure, duplicate code or modules, and lack of automated tests.
What causes Technical Debt?
We can assume that a business will undergo technical debt at some point. But there could be red flag warnings, the expected causes that one can watch out for to avoid falling into the debt trap. Here’s one such list of possible reasons why technical debt occurs:
1. Prioritizing Faster Time to Market
Organizations in product development believe in the “just ship it” philosophy.They develop pressure on the Agile development team, who then choose to ignore the incoming bugs across past sprint cycles and instead move ahead with developing messy codes. This, in turn, leads to increased technical debt as the existing inconsistencies in the code are left unattended.
2. Misinterpreted Definition of Done
In Agile, “Definition of Done” implies — a pre-decided list of tasks that need to be completed before considering a user story to be complete. Agile teams often consider a user story in agile to be done once it is passed on to the QA testing team or once the feature is launched in the market.
In reality, the changes based on testing reports/user feedback are not part of the definition of done, which leads to increasing technical debts. In other words, prioritizing project mindset over product mindset leads to tech debt when iterating through the Agile lifecycle.
3. Obsession with Product-Market Fit
If a product can solve a user pain point and is accepted by the customers, it is considered a product-market fit. And achieving this product-market fit is all that organizations care about.
Messy code and unresolved issues are ignored as far as product-market fit exists. However, organizations fail to realize that this ignorance can cost much in the long run by piling up technical debts, leading to performance issues and, thus, disrupting PMF.
4. Feature Creep & Architecture
It is the characteristic of software requirements to increase at any point in the software development process. This unpredictability and need for constant change lead to a change in plans and sprint prioritizations.
More often, the bug fixtures take a back seat and are left for tomorrow to accommodate the newer requirements in the product backlog. Hence, the increasing technical debt.
Examples of feature architecture problems? A failure to update hosting environments, back-end databases or servers, and infrastructural platforms; codes or software that builds poor interface; and inconsistent data models leading to poor data quality.
5. Exceeding WIP (Work in Progress) Limits
WIP limit refers to the maximum amount of work that can exist in the status of a workflow. Ideal WIP limits can be “number of team members +1 to start with.” If the WIP limit increases, it can lead to confusion with priorities and work overload (irrespective of its urgency). This, in turn, affects productivity as the development team works on completing tasks without worrying about quality delivery. Hence, the technical debt.
6. Unmanageable Growth Velocity
Sometimes the velocity of new feature requests is so high that teams lose focus from technical debt. Technology becomes outdated, software becomes obsolete, and sometimes today’s language might not exist tomorrow. The pressure of either adding new features or coping with constant upgrades could lead an organization into a technical debt trap.
Take the example of Facebook. They get new feature requests so often that their development teams are busy serving them. This, in turn, draws them away from the increasing technical debt, which, thus, keeps growing and reaches a stage where it gets unmanageable.
7. Business Strategy and Resources
Sometimes organizations fail to enumerate the holistic business strategy or the underlying capabilities needed, leading to distorted working plans and a base for technical debt. Insufficient coordination between IT and the strategy or a mismatch between the funding capability and business strategy can be reasons for shortcuts in coding or other technological processes.
When organizations have poor project planning and prioritization of projects, unrealistic or mismatched deadlines build up. That often leads to unrealistic time targets and shortcuts in software development. Complex product choices, lack of standardization in processes, and unplanned applications often become the basis for technical debt in software development.
Moreover, when organizations can’t prioritize project backlogs or coordinate proper task planning tools, there are bound to be situations where developers cut on efforts to create software.
Internal and external skill gaps damage organizational capacity, eventually leading to resource risks and causing delays in product delivery. Fear of uncertainty might make a lesser skilled developer team opt for technical debt. Teams focused on only short-term delivery would invariably create situations of technical debt.
An organization needs to be aware of these warning signs so that the technical team can devise processes for reducing the technical debt in software development. If technical debt is left unattended, it can escalate total ownership cost, longer time to market, declining agility, and low customer experience.
How to Identify Technical Debt?
Here are 12 signs that will help you identify the presence of technical debt in your existing projects. These include-
- The product backlog is expanding daily, while the productivity seems to deteriorate.
- Upon analyzing, you realize that the WIP (Work in Progress) limit has increased to the number of team members plus “n.” The Agile team is all packed up and has low bandwidth for working on amendments.
- The frequency of bugs increases. This could result from the development team struggling with managing the variable product backlog and pressure from the product manager.
- The source code is pretty long and exceeds the expected space it covers. This could be because of the messy code and antipatterns injected in the code.
- If adding a new feature or making amendments to an existing element means that you need to rewrite a large chunk of current source code
- Technical debt is evident if unit testing a module is painstaking and complicated.
- The result of the quantified cost of delay (the implied cost of delaying the launch by one week, one month, or a year) is much higher than expected.
- The frequency of hotfixes (code that helps fix a bug) seems to rise.
- The continuous increase in lead time is noticed along with the decrease in velocity, which puts you in a tight spot.
- Increase in write-only code, i.e., the code that is hard to read through.
- There is a technical debt if the burndown chart shows many pending works in the backlog.
- Gold plating, i.e., unnecessary items in the product backlog, leads to technical debt.
How to Measure Technical Debt?
The first step the product development team takes is Quantifying technical debt before managing it. Several technical debt tools can provide an estimation of the incurred debt. Here’s a table that gives you an overview of each of them:
|1. Sonar Cube||Open community tool to help developers write cleaner and organised code
The tool has a quality gate metric that qualifies your code against code smells, debts, vulnerabilities, and bugs
|2. Coverity||Focuses on delivering software quality.
Helps identify resource leaks, memory, corruptions, error handling issues, and more.
|3. Checkstyle||Helps scan and analyze java code with respect to coding standards
Checks code layout, formatting issues, overall code layout, and class layout issues
Another method for measuring technical debt is the “Technical Debt Ratio” (TDR). It is a complicated process compared to automated tools that facilitate automated calculations.
Technical debt metrics that you need to take into account while calculating the ratio:
- Development cost calculated in hours — time taken to develop a feature/product
- Lines of code (LOC) — the total number of code lines
- Cost per line (CPL) in hours — time to write a line of code
- Remediation cost in hours — time to make a repair
Here is the formula for calculating the technical debt ratio:
Technical debt ratio = (Remediation Cost / Development Cost) X 100 Where;
Development cost = Cost per line (CPL) X Lines of code (LOC)
Prefer maintaining a low TDR percentage at all stages. A value less than 5% is relatively considerable for Agile teams. However, this value depends on the project size and scope, and every team has defined ballpark TDR values considered standards.
What are the Different Types of Technical Debt?
Martin Fowler introduces different types of tech debt in the form of a quadrant, which he refers to as the “Technical Debt Quadrant.” Let us have a look.
Here’s what each of them implies:
This can be linked to the intentional injection of technical debt in software development. This is also called ‘planned debt.’ An organization decides to generate some technical debt, fully understanding the consequences (risks and costs).
The two interpretations of reckless and prudent apply-
- Reckless: This type of debt is the result of bad software architecture. In this case, the development team believes they do not have enough time to build organized code as they focus more on shipping faster.
- Prudent: In prudent debt, the technical debt is small and manageable. Thus, the tech debt can be avoided as it is mainly related to the code that rarely needs modification.
This can be linked to the unintentional injection of technical debt in the software development life cycle. Unintentional technical debt can occur due to poor technological practices, inexperience with new coding methods, and rollout issues—inefficient coordination between developers and operations teams.
The two interpretations of reckless and prudent apply:
- Reckless: In reckless inadvertent debt, the development team lacks knowledge and experience around best Agile practices. This might be a case for organizations halfway on the road to Agile transformation. They unintentionally build up debt, which becomes difficult to handle later.
- Prudent: Once the feature is done and delivered, the team realizes they could have done better (credits to their learnings). This is referred to as prudent inadvertent debt.
The terminology of ‘intentional’ and ‘unintentional’ debt came from Steve McConnell in 2007, and Fowler built on it and presented the quadrant. Later, around 2014, some thinkers proposed that technical debt be classified by its nature. They suggested that the categories could be Architecture Debt, Code Debt, Design Debt, Infrastructure Debt, Service Debt, Process Debt, Test Automation Debt, etc. (Ref: paper by Software Engineering Institute as “Towards an Ontology of Terms on Technical Debt.”)
What is the Cost of Technical Debt?
If you come to analyze the cost of technical debt, you’ll know why it is essential to identify and manage it.
The Cost of ‘Technical Debt’ Per Average Business Application Exceeds $1 Million.
— IT Business Edge
Here’s what you will lose if technical debt is ignored:
- Delayed bug fixtures and new user story launches will lead to a loss of customer interest.
- You will have to recruit more staff to identify and manage technical debt, which might take even longer to get back on track – these are the ‘talent costs’.
- Software system outages resulting from continuous code modification for bug fixtures or feature additions. System downtimes, low performances, and customer dissatisfaction could increase maintenance and support costs.
- Ongoing performance issues negatively impact the product’s responsiveness and hinder innovation in the long run.
Organizations often fail to give importance to the hidden costs of Technical Debt. There can be a total lack of motivation for developers as they go through cycles of unpredictability. The total cost of ownership of a business increases with operation costs increasing, talent time absorbed, and the support required for repeated tasks.
Is Technical Debt Bad?
Any type of debt is bad. For example, when you have incurred debt in your name, you will have to repay it sooner or later. There is no running away from it! Similarly, carrying a technical debt might seem worth the risk as you get an early launch and more features, but you’ll eventually have to pay it back. But if you keep delaying the payback, the impact of technical debt will be adverse as messy becomes messier, and product backlog becomes unmanageable.
Talking with experience, we believe that zero technical debt is a myth.
Although there is always some technical debt, the effort should be to keep trimming its branches to limit its spread.
Let us take an example here:
The good debt:
- You launch the MVP on 1st Feb 2021. You disrupted the market with an early launch — you gain a competitive advantage
- Meanwhile, the Agile team is working on adding some new features, i.e., the nice-to-haves, which they prioritized post the MVP development and launch.
- The initial feedback based on the MVP comes in within a month.
- A backlog grooming session is held to prioritize the tasks, including both the new features + the refinements to existing ones.
The bad debt:
- The Agile team’s workflow is disturbed as they now have to focus on improving the existing features.
- However, the team often focuses more on building new features and delays improving existing ones.
- Even if the team chooses to improve the existing features — iterating through the source code becomes impossible. This is because of the poorly written code to rush up the launch.
- Newer feature launches get delayed, and so do the refactoring activities — the upshot is a bad customer experience and increased churn rates.
Sometimes, the delivery of a project is more crucial than the perfection in code. The organization might opt for it if the developers feel the product could work for the user without its best or cleanest status. However, if the developers focus on innovative features that are not so important and cause a delay, it would be a “bad” technical debt. It serves well to remember that technical debt needn’t always be classified as good or bad. Opinion varies in this aspect.
There is pressure on companies to push product delivery and software development in the present times. Agile teams also suggest that almost all software will have some debt, and attitudes toward technical debt can vary across companies, departments, and roles.
The overall context determines whether a technical debt is good or bad.
When to Accept Technical Debt?
Some technical debt always exists, so it is recommended never to obsess over eliminating it.
Accepting technical debt is sometimes better than wasting your resources fixing it. But, how do you know — when to take technical debt?
It would be best if you accept technical debt in the following scenarios:
- You are onto small-scale product development, where refactoring is easy and quick.
- When you are building an MVP with minimal features. In this case, you can afford to wait for initial feedback to validate product-market fit before choosing to refactor
- You have an experienced team that understands technical debt and is ready to go the extra mile to manage it.
- You are trying your hands at new product development that includes an out-of-the-box feature that solves a user problem. In this case, launching the MVP with this must-have feature should gain focus (while you can ignore tech debt until its market acceptance)
- You want to be the first to market for a competitive edge.
If the Agile team keeps borrowing the technical debt, it might become impossible to repay it later. This is why following best practices for reducing technical debt should take precedence.
Managing Technical Debt
Here are some proven techniques for technical debt management:
1. Change in Organizational Culture
Builds an open organizational culture where teams can discuss the challenges in achieving their goals.
Addressing the elephant in the room, i.e., the reasons behind technical debt will help strategize around managing the workflow and build realistic timelines for completing tasks.
2. Take Daily Standups Seriously
The teams should be able to talk about the challenges that they are facing without hesitation. However, this happens to be a common Agile antipattern in distributed teams. Likewise, the scrum master’s responsibility is to ensure that the highlighted challenges are addressed immediately, such as meeting unrealistic goals in a limited time.
3. Balance Sprints
Keep a day in a week (for small-scale projects) or an entire week (for large-scale projects) to manage pending tasks. For example, when the team is done with building a new user story, they should be given a day in a week just for bug fixtures in existing features. This way, they can work effectively on the new user story while also paying the technical debt related to completed user stories.
4. Collective Ownership
Collective ownership implies that every development team member can change the code to develop a new feature, complete a pending task, or implement a bug fixture. By implementing collective ownership, the Agile team can reduce the technical debt – as the development team can distribute and manage work among themselves to build new features and simultaneously make changes to existing ones.
5. Prefer Quality over Quick and Dirty
Quality code should be preferred, even if it takes longer to get it done. Do not promote a work culture where development speed is a measure of productivity, and the accurate measurement of productivity should be quality at any given time. If the team creates messy code to facilitate fast shipping, maintaining it becomes similar to grasping at straws with no improvement. So, ship fast but not by compromising on the software architecture.
6. Introduce CI/CD into the process
Implementing CI/CD is synonymous with introducing automation testing in the development process. CI/CD will help run automated tests for the developed user stories, which will help report bugs faster. The development team can fix the bugs in the following sprint cycle, reducing the probability of existing bugs in delivered and deployed user stories.
7. Manage the Load
If the developers are stocked up and have aggressive timelines to meet the launch date, they will likely choose an easy way out — sometimes in messy codes. In this case, the developers only do their job to complete it while compromising quality. So, unload your developers and set realistic WIP limits for them. If they have less mess to handle in the product backlog, the code quality is less likely to be jeopardized, implying less technical debt.
8. Daily Refactoring vs. Sustainable Refactoring
Regular refactoring should be standard practice if you work on a small project. The developers should be given enough bandwidth in their daily schedule to fix bugs. Daily refactoring leaves the development team with minimal debt at the end of the software development lifecycle. The other type of refactoring is sustainable refactoring, which can be another practice. Here the team focuses heavily on developing new features (80%) and refactoring the written code on a small scale (20%). This allows for eliminating technical debt sustainably.
9. Rely on Microservices Architecture
Microservices architecture introduces loose coupling where a complete feature or a module is independent of other features/modules. If a particular feature suffers downtime, the other features still manage to function due to loose coupling. If there is a need to call out another feature, it is done with APIs. Relying on microservices is an excellent way to reduce performance issues due to technical debt because — when the team is busy refactoring one part of the software system, the other parts continue to operate normally.
Technical debt is a genuine concern for software development companies, no matter how small or large the project. Organizations always seem to run behind in serving new feature requests and shipping them faster, leading to bad code quality and skipped refactoring.
The opportunity cost of shipping faster than maintaining a high code quality can sometimes be higher than the profits incurred. This is why paying off technical debt is essential, like any financial debt, which is a critical lesson for effective product development.
What is Technical Debt in Agile?
“We need to launch the innovative feature within a month,” said the product owner.The developers accelerate the work on the new proposed feature in the planned sprint cycles.
But, in the process — delay bug fixtures in the developed user stories and write messy and disconnected code.
The upshot: The team manages to launch the new feature on time but at the cost of over accumulated bugs across sprint cycles and uniterable code. Thus, leaving them with unwanted technical debt.
We can thus, define technical debt in Agile as:
Technical debt is the implied cost of additional work related to — choosing a shortcut to software development and ignoring the pending bug fixtures (in advanced features) to work on new features with the intent to hit the launch dates.
Simply put, it is about preferring incremental development while ignoring iterative development in Agile. However, this practice only offers short-term benefits as it compromises long-term value.
Although the product backlog prioritizes the changes needed to the already developed features in the consecutive sprint cycles, they are often left unattended.
However, another interpretation implies:
Technical debt is the implied cost of additional work related to — writing messy or unrefined code when in a hurry to launch, which will get challenging to refactor later. This interpretation is directly linked to software architecture — building organized code for making refactoring easy.
Who is Responsible for Technical Debt in Scrum?
Holding a particular team or an individual accountable for technical debt kills the foundation of Agile, which focuses on collaboration and cross-functional setup.
So, the correct answer to who is responsible for technical debt is — Everyone!
Every team and each individual is somehow responsible for incurring technical debts.
- Development Team: when setting WIP limits, the development team should voice their opinion on how much work is acceptable. If they don’t talk initially, the cost of technical debt increases
- Product Owner: prioritizes tasks for the Agile development team. If the product owner creates aggressive goals for the team, they either follow shortcuts or write messy codes to comply with work commitments.
- Top Management: if the top Management forces a culture where deliveries are given precedence over quality work, the technical debt is likely to increase
- Scrum Master: is responsible for identifying and removing the obstacles restricting quality software development. If the scrum master fails to see the development team’s struggles w.r.t. managing quality deliveries, technical debt can worsen.
Frequently Asked Questions
1. What is Technical Debt vs. Maintenance Debt?
Technical debt is a short-term debt, primarily undertaken deliberately within a project. It can even be budgeted for in certain situations. Maintenance debt is long-term debt over which the teams do not have any control, and this needn’t have been budgeted for (e:g repair of all equipment in need of repair).
2. How do you save your business from a high technical debt?
A good business quickly notices the red flag warnings of technical debt happening. Special efforts should tackle a technical debt story discussed every month. Business Companies Corporate technical debt management into their culture.
Is your organizational and technical debt burning your revenue charts?
Let our experts guide you on smart debt management.