Dave Donaldson

Balancing Technical Debt with Feature Work

Tuesday, October 14 2008

A big topic for us right now as a product team is technical debt, and it's something that has taken on greater importance as we continue to grow. It's natural for software projects and products to incur technical debt, and depending on the situation, it might have even been the right decision at the time. However, if not taken care of, technical debt can get out of control very quickly.

For example, let's say that because of an important deadline, you cut a couple corners to implement an important feature. You didn't really feel good about cutting those corners, but after talking it over with the team, you realized you'd miss the deadline if you tried to implement the feature in the "ideal" way. So even though you weren't overly happy about it, it was the right thing to do, and you have happy customers (and revenue) to prove it.

And like any normal developer you tell yourself, "As soon as this version ships I'll go back and do it right". But that doesn't happen because the next product cycle starts and more features need to be implemented. The market you're in is highly competitive and you've got to keep delivering to minimize the risk of losing valuable business to your competition. So you don't make it back to fix your cut corners, and then a funny thing happens: someone else implements a different feature, sees the way you implemented the previous one where you cut corners, and then they copy that pattern, thus proliferating the technical debt. You can imagine how quickly this adds up over the course of several release cycles.

The challenge in an environment like this is figuring out how to balance the need to address the technical debt while at the same time continuing to deliver new features. It doesn't make good business sense for you to stop all feature work to perform a big refactor job. Afterall, those features *do* work, they work well, customers are happy, and you continue to bring in revenue.

So what is the right balance and how do you manage it? Admittedly, it's a hard problem to solve, especially with regards to anything of significant size and/or complexity. My experience has been to identify one or two people who's responsibilities include keeping a *constant* eye on alleviating technical debt while allowing feature work to continue moving forward. From a hands-on perspective, it's basically on-going refactoring for the life of the product. It's a unique ability to be able to do this, but one that's critical to the overall health of the system.

Balancing technical debt with feature work is extremely important and cannot be overlooked. On one hand you can't simply stop new development and on the other you can't just keep letting the technical debt pile up. Balance is the key and needs to be tailored to the specific situation (product, people, deadline, etc), knowing that each situation will be different. Just make sure that you first acknowledge your technical debt and then you can make a plan to begin addressing it.