What is technical debt?
Technical debt refers to the costs that are accrued as a result of implementing easy or quick coding solutions that work in the short run, rather than a best practice approach that would take longer. This "debt" is usually paid in development time, and always needs to be paid eventually. Technical debt may not effect your launch cost, but it will always impact your bottom-line. Sometimes, the debt can spill over into customer facing operations in the form of live site bugs, which can frustrate and alienate potential customers.
Accruing technical debt causes wasted development hours later on in the process, time which could have been used to enhance production features or otherwise grow the project.
Ward Cunningham was the first person to refer to short term fixes that did not translate into future program iterations as a "debt." Cunningham came up with the idea of technical debt by equating the software development process to the concept of financial debt. This analogy is especially relevant because of the assumed interest that technical debt brings with it. Developers will spend more time in the future (the interest) to pay back time saved in the initial coding. Usually, the longer the short term solutions are left, the larger the payback of development hours needed in the future.
How can technical debt arise during the application development process?
1. Technical debt can occur due to a lack of understanding of the process. This is especially prevalent in segmented development teams. If there is not a shared vision, one development leg may organize code differently from another leg. This will require coordination that will take more time to implement in the future.
2. If a project does not align itself to standards, whether internal or external, the technical debt amassed can be substantial. For example, if developers are working in segmented teams on different pieces of an application, when it comes time to join the codebases disaster can ensue if the same standards are not followed by all teams. This will lead to lost time, timeline delays, and lots of frustration for both stakeholders and developers. These issues could be avoided if standards were documented and adhered to from the beginning of the project.
3. A lack of resources can cause technical debt. If a development team is understaffed and pressured by a deadline, short term coding solutions may be the only way to meet expectations. However, any updates to that program will likely face a great deal of technical debt, especially if new APIs or standards must be considered.
4. If a project is mis-timed, technical debt may also show itself. Last minute requests and changes are a huge cause. A client may believe his request to be a simple add on, not understanding that even the slightest change can cause a need for refactoring large aspects of the code. Developers may not be able to implement the optimal solution, leaving the project with code bloat that may slow operations or cause bugs to appear.
5. Simple laziness is probably one of the more common sources of technical debt. Most developers with at least a couple years of experience are aware of the right or wrong way to write and maintain a code base. However, short-cuts are also fairly common- something that will save a developer time in the short-run, but cost the company dearly in the long-run.
What are the consequences of not addressing technical debt early on?
There are many consequences to ignoring technical debt, and the longer you carry that debt alongside you, the more critical those consequences become. The codebase in a project with technical debt will become outdated more quickly, ironically causing a need for a more timely update. The larger a project becomes, the more technical debt is amassed with each shortcut.
The most common result of accruing technical debt is a sharp rise in development hours for any further change to your application. Scaling a project ridden with technical debt can become a black-hole of hours, and can even hault progress until the debt is addressed and the code refactored.
Technical debt may also cause a project to become a security risk. As more bugs show themselves, your security becomes more at risk. This is especially important to note in applications that take the personal information of clients.
Most instances of technical debt eventually cause the budget requirements of a project to increase- both in terms of time and money.
When is technical debt especially important to consider?
The technical debt load becomes more important to consider the larger a project will become. If a project is scheduled to evolve over many generations, technical debt must be addressed early in the process and not allowed to accumulate under any circumstances. Large web application or complex CMS projects are major examples to consider.
What are some of the top ways to combat technical debt?
1. Consider your resources from day one. If you do not have a reputable resource or the internal staff to correctly build a project from the start, it may be wise to reduce the scope of the project or spend time searching for a resource that you can trust.
2. Create and share a clear vision. All people involved in the development process must understand the project from an execution and big-picture standpoint. There are many ways to get to the same final outcome. If everyone on a development team has the same vision, the journey to the finish line will be taken along the same path, which will reduce technical debt.
3. Document all aspects of production. In many cases, technical debt is unavoidable. However, the ability to find the process bottlenecks may help reduce the size of the debt to be paid. As the codebase becomes larger, zeroing in on the aspects of code that could be improved and documenting them becomes an essential process.
4. Dedicate the appropriate resources at the beginning of the process. Saving money on initial execution is not always the best business decision. Consider the notion of technical debt when creating an initial budget. It may actually save a company money to front load resources and spend more on day one.
Conclusion
Technical debt is an important concept to understand and consider when creating any new digital product. The debt accrued during a project cannot be avoided, and will always need to be paid. The longer you wait to pay, the larger the cost. Making a few small tweaks to your budget, process, and team can be the difference between having a manageable amount of technical debt and being drowned by it.
