What technical debt looks like in software
A typical example of technical debt can be found when a company implements “patches” that fix issues in their software but don’t take into account the software’s future needs. In a common scenario, developers can find themselves patching the patches until the code becomes overly (and unnecessarily) complex, making each subsequent change more difficult than it ought to be. Redundancies build up, updates require many other updates, and the code itself becomes nearly impossible for new developers to wrap their heads around.
Because of how time-consuming (and expensive) it can be to properly address technical debt, companies often choose not to deal with it early on. This causes more and more defects to stack up until a true fix requires a herculean effort and a substantial investment.
It should be noted that it’s sometimes more desirable to bring something to market quickly than it is to have something completely future-proof and free of technical debt. It is, however, important to understand what causes technical debt and the measures that can be taken to reduce it.
What contributes to technical debt
Below are some common things that can cause technical debt:
- Time-to-market pressures
- Technical decisions made by business managers
- Lack of knowledge (by developers / architects) about future business goals
- Source code complexity / bad source code
- Insufficient / poor documentation
- Poor testing
- Lack of adequate developer / manager collaboration
- Postponed refactoring
“Shipping first time code is like going into debt. A little debt speeds development so long as it is paid back promptly with a rewrite…. The danger occurs when the debt is not repaid. Every minute spent on not-quite-right code counts as interest on that debt. Entire engineering organizations can be brought to a stand-still under the debt load of an unconsolidated implementation, object-oriented or otherwise.” ~Ward Cunningham
How you can avoid technical debt
Technical debt is one of the most frustrating things that a business owner or marketer can face when it comes to technology. As you can imagine, it is expensive and can debilitate your product in ways you never predicted. With that in mind, the following tips offer guidance on how to avoid unnecessary technical debt before starting and moving forward with any web development project.
- Plan for the (far) future. When embarking on a web application development project, try to envision the features that it might need to have, and the users whom it might need to serve, far into the future. For example, will it need to support a large user base – and therefore scale exponentially? Will it need to have an API through which developers outside your company can connect to it? Will it need integrations with third party applications or services? Be sure to share your long-term vision with your software architect and development team. Your vision will likely affect how the application is created – and with careful planning, your technical debt can be significantly reduced.
- Resist the temptation to save time and money. Resist the urge to hire the cheapest developers you can find, or to outsource your software project to a low-cost company overseas. While you might save some money in the short term, your application is likely to be built without level of quality needed to support future upgrades and growth, increasing your technical debt and making it extremely expensive later on. You might need to make exceptions to this rule if you have a limited budget and/or need to bring your product to market quickly – but be aware that you will likely need to embark on a rewrite after funding comes through, and proceed with caution!
- Assign the right person to deliver your technical strategy. Just because you think you know what your end product should look like, doesn’t mean you know how it should look from a technical perspective.
- Lean on your developers. If you are working with a good development firm, chances are they’ve worked with other companies that have faced barriers similar to those that you will face. They can often spot the risk of technical debt much faster than you can because they’ve experienced it on other projects and likely, at some point, have needed to reverse overdevelopment. If posed with the challenge, there is a solid chance they will be able to identify code that isn’t quite structured as it should be. Make it a habit to get their feedback before starting to code any major new feature.
- Uncover areas of overlap. Often, unbeknown to you, your application contains code that can be used for multiple functions. It is often best to reuse the same code in different places rather than re-developing it separately (which increases the odds of acquiring technical debt). Discuss this up front with your development team as they will be able to see things on their end that aren’t so obvious to you.
- Have your checks and balances in place. Assign the right person to be in charge of avoiding technical debt throughout the development process. Make it their job to call out and push back on unnecessary coding along the way.
- Bring in a second eye. And a third, and fourth if you can. Every business owner and manager should make it a priority to surround themselves with mentors who have been there. These people will be able to identify holes in your development plan by drawing on their own unique experiences.
- Roll out in phases. This can be especially hard for entrepreneurs who have a longer-term vision. Regardless of the idea, it’s very important that you create and test the minimum viable product first. This should be the foundation of your business. All of the bells and whistles can wait until you prove that your foundation is solid. This approach has been shown to eliminate significant amounts of technical debt for businesses.
- Test. Test. Test. The more you test your product, the more familiar you will become with it and the more obvious areas of concern will be. Testing for bugs is one critical piece of the puzzle. Testing to avoid an overage of technical debt is another. Start testing as soon as you have the minimum viable product ready and continue testing after users get in there.
- You will have some debt, so pick and choose wisely. Every web development project begins with technical debt and more debt will be acquired along the way. Make it a habit to ask yourself – Is this really necessary? – before adding any functionality to your product and you will be much better off down the road.
If you have questions or concerns about technical debt at your company, contact us for a free code review and technical consultation.
