Technical debt

Every line of code you create, must be maintained at some point in the future

Technical debt is one of those things that is difficult to explain to middle and upper management. Especially in companies that are creating software as a secondary function. However, it’s really quite simple to understand; It is the cannibalisation of future freedom and manoeuvrability in order to reach short term goals. Logically it’s the exact same thing as borrowing money today, without any thought of that you’ll need to repay your loans later. Therefor it becomes crucial for a company to understand this concept. Without an understanding of technical debt, it becomes impossible to create a sustainable business – At least a business that employs software developers.

The primary cause of technical debt is “code”. Every time you need a piece of software, you should ask yourself if you can get away with avoiding creating it yourself, and use off the shelf components instead. Every single line of code you don’t create, is one line of code that can never create technical debt for you. This is arguably the sole reasons why companies choose to create products out of code, since it allows one company to take on technical debt on behalf of other companies, in return for some monetary gain of some sort. This is why most companies chooses to purchase a word processor instead of trying to create one themselves. At the same time, owning (some) software can have strategic value for a company. A company that exclusively chooses to purchase its software as third party components, doesn’t have anything special that separates it from the herd. The key as always is to balance things.

Basically, you want to create as few lines of code as possible, while still retaining your competitive edge, making you unique in your market.

Due to that it is so difficult to understand this concept, it becomes crucial to make sure you hire people that do understand it. Hiring only junior developers, results in unimaginable amounts of technical debt, since juniors don’t have the experience required to understand the consequences of their actions, and that their “brilliant solutions” are things that needs to be maintained in the future. And the result becomes that the company increases its technical debt, until it can no longer sustain its operations – The same way a loan of money is defaulted upon due to not being able to pay the installations leads to bankruptcy. By all means, hire junior developers, but make sure you’ve got at least one developer in your organisation that understands the consequences of what is pushed into your GIT repository, and that can explain it to you, such that you can understand how your company is actually performing – Otherwise you might as wells start flipping burgers immediately, since that’s where you’ll inevitably end up at some point anyway.

A key component to avoiding technical debt is to ask yourself the following question every time you’re tempted into creating a piece of software; “Is this a part of my competitive edge, or is this something where I could get away with purchasing a third party component to solve my problems?”

If the answer is that you could purchase a third party component to solve your needs, but you still choose to create it for yourself – Then you are accumulating technical debt, and at some point in the future, your debt will come back to haunt you.

Leave a Reply

Please log in using one of these methods to post your comment: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.