With limited resources and high uncertainty, startups typically face extreme pressure to get to market quickly. As they make code-based decisions, these startups will likely focus on short-term wins to ensure they beat out the competition. With every corner cut, however, there’s a price to pay. That’s why in the face of pressure and uncertainty, startups are likely to accumulate some amount of technical debt.
Technical debt (also known as tech debt or code debt) is defined by our friends at ProductPlan as what results when development teams take actions to expedite the delivery of a piece of functionality or a project which later needs to be refactored. In other words, it’s the result of prioritizing speedy delivery over flawless code.
Technical debt is like any other debt. Let’s compare it to buying a new car. Most people don’t have tens of thousands of dollars to purchase a car in one fell swoop. So, people take out loans that must be repaid over time—generally over a number of years. And if buyers don’t pay their loan on time, they may find their car repossessed.
Tech debt is no different. Like the loan that allowed someone to buy a car, tech debt allows companies (especially startups) to create software faster. However, the form of repayment, in this case, is slowed software development in the future. Companies will eventually be forced to spend more coding hours and resources to fix the debt accrued upfront producing a product quickly rather than perfectly.
The biggest problem with technical debt is that it often leads to more debt—or worse, a misuse of the phrase to excuse poor practices. Over time, claiming debt has become synonymous with producing code that’s less than ideal. From software that runs slowly to lacking clear style, technical debt has come to mean writing code fast that alleviates immediate business (or industry) pressure but sacrifices quality.
And at the core, the problem with technical debt is similar to the definition it: prioritizing speed over quality. However, not understanding business priorities will ultimately disconnect appropriate resource investment from the generation of substantial business value.
In other words, software development without clearly-defined reasons for prioritization will be a massive source of wasted time and money.
While technical debt can certainly justify an iterative, experiment-based approach to software development, there are ways that you can minimize the debt. Here are three techniques development teams can leverage in order to do so:
Pair programming is the practice of two developers sharing a single workstation. And we don’t mean the shared workspaces of modern offices, but the literal sharing of one monitor, keyboard, and mouse between a pair. The developer at the keyboard is usually called the ‘driver,’ and the other person who focuses on the overall direction of the task is called the ‘navigator.’
The goal here is to produce better quality through a “two heads are better than one” approach. Not only does this benefit the quality of the end product, but in the startup world, where turnover can be frequent, developers won’t have to pick up with a line of code they’re unfamiliar with. This can ultimately save time in the long run and reduce unnecessary debt.
Test-driven development is a software development process that relies on the repetition of very short development cycles. The process is pretty simple. Developers begin by writing an automated test (that will initially fail) that defines a desired improvement or new function. From there, the developer will then write the minimum amount of code to pass the previously developed test. Finally, the code will be refactored and optimized. Lather, rinse, repeat.
While the process may seem overwhelming at first, it provides assurance that the code is always tested. (And not before it’s too late.) By employing TDD you can avoid technical debt by coding in smaller chunks that likely won’t need rework in the future.
Methods like pair programming and TDD are great, practical ways to reduce debt, but there’s a level of upfront work (prior to ever producing a line of code) that can help reduce debt. By building discovery tests, through human insight software, businesses can ensure they’re prioritizing development work by fully understanding the pertinent needs of the customer.
From needs discovery to concept validation, the opportunity for minimizing tech debt is clear. And it begins by letting your customers prioritize your roadmap for you.
In the end, customers don’t care what your code looks like. They just want a product that works and meets their needs. For a startup, accruing some technical debt to build an imperfect product that provides a handful of meaningful features that users love is massively valuable.
Once you find success and traction in a few key features, leverage some of the techniques above to begin paying back on your tech debt. And always, leave your code in a better place than when you got it.