Technical debt and its importance is something that is becoming well-known in the software development world. But what exactly is technical debt? And how do you know if you’re in too much of it? What are the ramifications of having this kind of debt?
However, the big question you should ask is, does it really matter? And the short answer to that would be it depends! Again, we don’t apologise for this less-than-specific answer because it is what it is and is difficult to be specific about, although we do want to help you better understand it and how context determines the extent to which technical debt can impact your business.
If you’re looking for a long answer, this blog post is for you. Today, we’ll break down exactly what technical debt is and explore some ramifications of raising too much of it.
We’ll share tips for avoiding or reducing technical debt and discuss key concepts about this fascinating topic. So, read on to learn more! 👇👇
In the simplest form, technical debt is any code or software development work you do now for a short-term gain that will take longer to fix or rework later. But, you might think, why not do the best job right now instead of fixing it later? And that’s where prioritisation comes into the picture. What matters to your business? Short-term benefits or long-term gains? The answer to this question usually dictates how much technical debt you’ll build up.
If we want to go slightly nerdy with this, then technical debt results from prioritising speed and delivery over perfect code. Technical debt is also commonly referred to as design debt or code debt.
In terms of what constitutes this form of debt, then in general, code debt would encapsulate everything from bugs, errors, untested code or poorly written code to even missing documentation.
The term was first coined by Ward Cunningham, one of the pioneers of the Agile Manifesto, to explain the inner workings of budgeting in software development to external project stakeholders. He created the concept to help stakeholders understand how compromising code and application quality in the present will inevitably lead to negative consequences in terms of additional costs, resources and time.
That said, technical debt may not be the worst thing for everyone. Yes, that may sound counterintuitive, considering it is a form of debt you’ll have to repay. But in some cases, technical debt is necessary for progression and growth.
Take startups, for example. Such companies tend to be in a perpetual state of sink or swim. Time to market is their number one priority; thus, pursuing technical debt over a delayed launch becomes a viable and, in most cases, the preferred option.
Another example is if you’re building up an application with a fixed launch date that cannot be altered in any circumstance. In such cases of a time crunch, embracing acceptable levels of technical debt may be the only feasible way to ensure project completion.
Another point to note about technical debt is the type of project management ideology adopted and prevalent in your company. The idea of technical debt is more suited to projects following an iterative approach such as the agile methodology. You can accumulate specific amounts of technical debt with each iteration and work towards reducing said debt in subsequent iterative cycles.
Phase-driven methodologies such as waterfall, on the other hand, are relatively documentation-driven and have minimal tolerances for technical debt. Furthermore, you cannot move to a new phase without “total completion” of the prior, rendering the entire concept of technical debt irrelevant.
The origins of technical debt are closely linked to its financial relative. Let’s face it; technical debt is just a metaphorical embodiment of financial debt created to justify complex decision-making in technical aspects of projects.
Thus, it is no surprise that technical and financial debt have many similarities. For instance, these debts may not be a problem initially but can turn into major stumbling blocks later down the road.
Similarly, having either technical or financial debt may not be the worst thing for your business; in fact, it could be what is allowing your business to flourish in the short term, but inevitably both can become severe bottlenecks in the future – if left unchecked.
If technical debt could be simplified in one word, then perhaps that word ought to be “shortcut”. Think about it; you’ll be taking a shortcut to create a solution to a problem that will have to be certainly rehashed or remade later.
In a software development context, let’s say you build an application with either minimal features or features with less-than-scoped capabilities with substandard coding prowess just to achieve delivery targets. But we hate to break it to you, but this same software will be complicated if not impossible to maintain, scale and improve upon later – the reason being faulty foundations. Moreover, it’ll cost you more money, time and resources than if you did it correctly initially. Talk about a double whammy!
This would beg the question, is technical debt terrible? And, does it mean failure? Before you make any conclusions, hear us out. There’s a difference between technical debt and incompetence. Proceeding with a project built on poor coding practices would be downright foolish.
Make no mistakes; technical debt is not about creating a mess. However, there is a clear differentiator between the two: “intention”.
When done correctly, technical debt is based on strategic decisions made whilst considering all specific project constraints and circumstances. However, there are cases for young companies where embracing technical debt will be the only viable option, which is acceptable and, more importantly, manageable.
A mess, on the other hand, doesn’t involve strategic thinking. Instead, it is a by-product of laziness, incompetence and unprofessionalism – a far cry from technical debt.
To summarise, intentional prioritisation of “vanity constraints” such as speedy delivery over technical sophistication and long-term thinking causes technical debt in most projects.
We’ve already given you a snippet of this in the previous section, but let’s delve deeper into technical debt within a software development environment.
Consider this, you’re building a new software product, and you’ve documented all the features and functionalities required and set forth with the development.
Once all the features have been coded, you begin testing and potentially encounter a few roadblocks and bugs. While fixing said bugs, new issues are detected, jeopardising the project’s future.
You’ve now got a decision to make. Halt progress and work towards fixing all the bugs first and likely miss deadlines OR prioritise only the essential bugs and improve everything else at a later update.
If you chose the former, you would be free from technical debt but might not be able to launch within planned deadlines. On the other hand, if you go with the latter, you’ll be quick to market but will also have some work cut out for later, in the form of technical debts or defect debts that need to be paid off, i.e. resolved.
Constantly procrastinating on the bugs and roadblocks and setting them aside for a later release or update is a dangerous game and will inevitably lead to more frustrations and headaches if you don’t have an effective project management process in place.
There are different schools of thought when it comes to categorising technical debt. For the scope of this article, we’ll go over just two division criteria, and they are:
Here technical debt can be categorised as either intentional or unintentional and reckless or prudent.
Let’s go over these quickly. First, intentional technical debts are incurred due to conscious decision-making as a strategic endeavour. There is a clear purpose and reason behind why the technical debt was agreed upon and a clear plan to resolve it in the future.
Unintentional technical, also known as unknown or accidental technical debts, are generated without knowing when it was incurred along the project lifecycle, mainly due to incompetence and negligence. Think how much clean-up work a senior programmer would have to do if a rookie developer did the brunt of the project.
Silos in projects are different components of projects that co-exist to serve a common purpose. As a result, technical debt can be incurred in every project component, whether it is the code, design, prototype, or documentation.
Examples of technical debts based on this categorisation protocol would include design debt, documentation debt, code debt, defect debt, people debt, process debt, testing debt and so on.
The critical point to note about technical debt is that without considering context, you cannot deem it either good or bad. Technical debt is a concept where it is difficult to be subjective, as context and specific constraints play a crucial role in assessing the consequences and aftermath of technical debt.
Agile teams follow this same belief system. They consider technical debt a necessary evil and believe every software development project will inevitably have some form of technical debt, especially applications undergoing multiple iterations.
However, this belief is not shared by proponents of waterfall project management. As we mentioned earlier, waterfall projects have minimal tolerances for any form of project debt, as incurring debt and taking shortcuts defeats the purpose of this idealogy.
Moving to the corporate environment, business-level executives and staff have a higher technical debt threshold than technical professionals like developers and project managers. This is because executives want results now, but technical teams don’t want to be in the middle of an inevitable mess later, which they’ll have to clean up.
However, more often than not, business-level executives have their way not just because of their superiority from an organisational hierarchy perspective but also because communicating the implications of technical debt to business professionals tends to be a challenging task that most technical staff struggle with or have no interest in.
In essence, context matters when judging the consequences of technical debt, and it may not be wrong until it is.
For the most part, if technical debt is left in check and incurred with rationale decision-making behind then, it shouldn’t be a significant cause for concern.
On the flip side, if left un-managed or poorly managed, it can creep up and creep up quickly to the point where the business can be susceptible to severe damages and losses.
From a larger project and customer perspective, technical debt can lead to:
On a financial level, technical debt can be detrimental to:
Now that we understand how the business can be affected if technical debt is mismanaged let’s explore what it can do to your staff.
The burdens of the accumulated technical debt will fall under your team to resolve. Unfortunately, this can often lead to a plethora of dissatisfaction and a lack of enjoyment in one’s work.
Think about it for a second, building a new product or feature is often an exciting prospect, and rebuilding an existing product rarely feels the same.
Furthermore, ticking off the heavy workload of technical debt can result in internal conflicts and “blame games”, causing team morale and culture to suffer tremendously.
In conclusion, you could end up in a situation where your team lack spirit, productivity and a desire to perform. In addition, amid the pressure, the product might be rushed to finish incurring additional technical debt to sort out later. If that’s not messy, then we don’t know what is!
Constantly setting bugs and defects aside for later versions and releases is a troubling way of managing software development. Critically if this continues, the bugs will pile up to such an extent that it will seem too daunting even to attempt to resolve.
This will force you to delay schedules, provide poor customer service, and launch an inferior error-prone product that annoys customers and frustrates stakeholders.
Like we said earlier, some level of technical debt is acceptable, and the context behind it matters, but there has to be a tolerance limit, even if you are intentionally incurring said debt,
So, there has to be a better way of managing technical debt, right? And there are a few approaches that can surely help.
Whilst utilising the iterative process of software development, Agile also enforces quality standards that ensure each release is up-to-the-mark. “Close enough is not good enough” – each iteration has to meet a certain threshold to be deemed ready to be released.
In Agile, this level of quality is determined by the “definition of done. “Done” in an agile sense means when a product is ready for release, ready to be adopted by the end-users.
Thus, as the quality threshold is fixed and at a reasonably high standard, technical debt is kept at a minimum, even with iterative releases.
Keep in mind that the longer you put it off, the more difficult it will be to fix.
There might be some form of miscommunication or misalignment in how your company’s technical debt is understood by management and developers. For one group, it might mean something, and for the other, something completely different.
Thus, there needs to be a clear definition and distinction of technical debt so that all concerned parties are on the same wavelength.
One way to create this distinction is by separating good technical debt from bad. Usually, intentional technical debts created through a straightforward and planned decision-making process can be considered good technical debt.
Everything else would fall under the bad side of this umbrella. Think technical debt incurred due to poor stakeholder management, miscommunication, incompetence, poor processes, and misaligned recruitment, to name a few.
If a tech debt results in system failure or a terrible user experience issue, it’s a no-brainer that it must be fixed before the product reaches customers.
Bugs and issues that are not impacting the product’s intended functionality may be set aside for later with minimal repercussions.
Often companies will leave testing and QA as a separate phase or segment of a project. This approach can lead to defects and bugs being ignored in the development phase. Developers will start thinking, “I don’t need to fix this now, QA will detect it later anyway”.
To minimise coding debt, you must maintain high-quality coding standards and ensure testing and QA protocols are practised within the development cycle.
You don’t want to manually test an entire software riddled with buggy code a week before launch. A recipe for disaster, if there ever was one.
Write automated test scripts to detect bugs and slash away technical debt. Nothing is as effective as automated testing in preventing and resolving bugs.
This is how automated testing works. If you encounter a bug, your developers will create a piece of code or a “test” to replicate that same issue.
What this does is that anytime the bug is created, your test will catch it before customers even get a sniff. And because you would’ve already fixed it, resolving it now would be a piece of cake.
Automated test-driven development is one of the cornerstones of Agile development and is something most companies need to start implementing.
By this point, it should be evident that technical debt is not something you can afford to mismanage. However, it’s important to reiterate this vital takeaway in further detail to understand the concept completely.
Businesses want to stick by the “do more with less” philosophy, which works to a point. Stakeholders want the most fantastic application with state-of-the-art features and functionalities, and they want it now. Unfortunately, these expectations and requirements can cause a dilemma for developers who now have to play a dangerous game of choosing delivery speed over quality. This often leads to, you guessed it, technical debt.
Think of it the same way you would with financial debts. As you would with financial obligations, making a concise effort to pay the debt month-by-month will reduce the overall debt volume. However, you don’t want your debt to pile up to a level where it becomes almost impossible to address without taking drastic measures.
Because if that happens and your technical debt builds up to the point where it becomes too much, your team will have to stop working on the exciting “money-makers” and revert to rejigging and repairing existing products, costing the company time, money, and valuable resources.
Lastly, uncontrolled technical debt will also lead to a situation where you’ll be unable to meet changing demands of customers. In this digital age, the “shelf-life” of products and services is almost non-existent, with technology evolving almost daily at a rapid scale.
You need to be ready to capitalise on this and proactively hunt ways to innovate existing products to provide intuitive solutions built with the latest technologies. Unfortunately, pre-existing technical debt can stand in your way of doing this and cost you valuable growth opportunities and a competitive edge.
The concept of technical debt is a fascinating one. Of course, the inherent metaphor of financial debt helps a lot when starting to understand this idealogy, but there is much more than meets the eye.
Companies need to be aware of technical debt and its ramifications, especially if they are left ignored and unresolved for too long. However, with that said, context also needs consideration which is why technical debt may not necessarily be a problem until it becomes one.
We hope you enjoyed this article and found valuable information about all things technical debt. If you’d like to learn more about similar technical concepts and ideologies, then make sure to check out our learning centre.
If you’d like to discuss the infinite possibilities of scaling your business to the next level by utilising innovative technologies through intuitive approaches, schedule a discovery session for a further chat.
August 08, 2022