Ten types of technical debt
How do you describe your tech debt to business? Often saying, "We need to fix our technical debt," is not enough for the company to prioritize it. Here are frameworks that can help you with classification.
Ten types of technical debt
By Thoughtworks
Code quality
Testing
Coupling
Unused or low-value features
Out-of-date libraries or frameworks
Tooling
Reliability and performance engineering problems
Manual processes
Automated deployments
Knowledge sharing
By Google engineering
Migration is needed or in progress
Documentation on project and application programming interfaces (APIs)
Testing
Code quality
Dead and/or abandoned code
Code degradation
The team lacks necessary expertise
Dependencies
Migration was poorly executed or abandoned
Release process
Here, you can download the cheatsheet PDFs:
Detailed explanation
Google, ten types of technical debt
Source: Paper: "Defining, Measuring, and Managing Technical Debt"
Migration is needed or in progress: This refers to the need to migrate systems or code due to scaling requirements, mandates, reducing dependencies, or avoiding deprecated technology.
Documentation on project and application programming interfaces (APIs): This category includes issues with finding, missing, incomplete, or outdated documentation, as well as documentation related to APIs or inherited code.
Testing: This category encompasses problems with test quality or coverage, such as missing tests, poor test data, fragility, flaky tests, or frequent rollbacks.
Code quality: It refers to issues with product architecture or poorly designed code within a project. This may be due to rushing development or treating code as a prototype or demo.
Dead and/or abandoned code: This category includes code, features, or projects that have been replaced or superseded but not properly removed from the codebase.
Code degradation: It refers to code that has degraded over time or hasn't kept up with changing standards. This may include code in maintenance mode, requiring refactoring or updates.
Team lacks necessary expertise: This category pertains to gaps in the team's expertise, which may be due to staffing gaps, turnover, or inherited orphaned code/projects.
Dependencies: It involves unstable or rapidly changing dependencies that may cause rollbacks or other issues.
Migration was poorly executed or abandoned: This category encompasses cases where a migration was attempted but poorly executed or abandoned, resulting in the need to maintain two versions.
Release process: This category includes issues related to the rollout, monitoring, and maintenance of production systems.
Thoughtworks, ten types of technical debt
Source: Martin Fowlers' Bottleneck #01: Tech Debt
Code quality: Refers to code that is brittle, hard to test, hard to understand, or poorly documented, which makes development and maintenance tasks slower and demotivates engineers.
Testing: Lack of unit, integration, or end-to-end tests, or an imbalance in the distribution of tests, which leads to slower development, reduced deployment frequency, and more bugs.
Coupling: Excessive dependencies between modules or teams, especially in a monolithic architecture, resulting in reduced deployment frequency and increased lead time for changes. Moving towards microservices can be a solution.
Unused or low-value features: Having too many features that are not being utilized or adding unnecessary complexity, which slows down delivery speed and requires developers to work with more conditions and edge cases.
Out-of-date libraries or frameworks: Using older versions of libraries or frameworks that limit innovation, hinder security improvements, and slow down the onboarding process for new hires.
Tooling: Using suboptimal third-party products or tools that require excessive maintenance or are not as efficient as newer alternatives, leading to inefficiencies and frustrations for developers.
Reliability and performance engineering problems: Issues related to reliability, scalability, and performance that can affect the customer experience and hinder scaling efforts. However, premature optimization should be avoided.
Manual processes: Having manual steps in the product delivery workflow, either in the developer workflow or in managing the production system, which can be time-consuming and error-prone.
Automated deployments: Lack of automated deployment processes, which can lead to infrequent deployments and hinder rapid software delivery.
Knowledge sharing: Insufficient documentation, lack of API specifications, and architectural decision records, making it difficult for new employees and dependent teams to understand the system and slow down onboarding.
How to apply those practically?
Here is an example action plan of applying one of these frameworks quickly to your work.
1) Do the workshop with your team or other leaders to list all things considered as technical debt you face in your organization.
2) Classify according to one of the frameworks. You can use these Google Sheets:
Google: https://bit.ly/3NKv4Sp
Thoughtworks: https://bit.ly/3PTabHf
3) Once done, do value/effort classification for each of the items:
4) Prioritize things with the Product organization/business according to your classification.