It is challenging to choose the right tech debt to fix. My technical mind thinks that I should tackle the most challenging problems first. But my business mind makes me believe that I should focus on tech debts with the highest return of investment. Refactoring the most challenging, complex and problematic code would give us the highest return on the investment. However, tackling the most complex problem first consumes a lot of time. The longer we take to solve a problem, the longer the other problems are neglected. We need to choose our battles wisely

I am going to put tech debts in two buckets: Complex: Takes months to a year to ship with a high risk of customer disruption. i.e Break into microservices Simple: Takes a few weeks to ship with a low risk of customer disruption. i.e Refactor a class/function

| |Less time|More time — | — | — High-risk customer disruption | | Complex
Low-risk customer disruption |Simple| |
The investment returned on cleaning the Simple Tech Debt may be small, but you reap the rewards fast in small increments.

Following are a few examples of fixing Simple Tech Debts:

• Use standard/popular libraries that can replace custom code
• Use newer language features to reduce LOC and increase readability.
• Upgrade libraries to take for better reliability and productivity
• Improve telemetry and tracking
• Using better design patterns based on best industry practices

Solving simple Simple Tech Debts have the following benefits:

• Quick return of investment
• Less to no disruption to business
• Increases clarity of the source code, resulting in a better understanding of the system
• Prepares engineers to take on the Complex Tech Debts in the future

When you are cleaning tech debts and you don’t know where to begin, take the shortest path first. Also, don’t neglect the Complex Tech Debts for too long.