May 2, 2018
Are you already committed to technical ‘debt assistance’ for your business software? In the development of almost all software, a technical debt is built up, mainly in order to achieve results quickly. That doesn’t have to be a problem, as long as you handle it well and consciously. Because just as with financial debt, you do have to pay off technical debts in order to prevent the costs from getting higher and higher. And to prevent the debt from becoming unaffordable.
If you want to buy something, but don’t have the money, you can take out a loan. For some things that can be very responsible. It can even be a smart investment that pays you back generously. As long as you make a conscious choice and know what the consequences are. It’s exactly the same when it comes to technical debt. That blame arises when work in software development is postponed. It’s a ‘guilt’ because the work has to be carried out later.
Making the interest of speed
In software development, software engineers can make speed by (temporarily) cutting corners. Think of omitting certain tests or validation rules. Or by ‘hacking’ something into it, instead of neatly integrating it into the software architecture. Or copying entire pieces of code and modifying a rule to create an exception for a customer, instead of neatly integrating that exception as a configuration option. These are very costly decisions that you can make as a software engineer, under the pressure of quick to deliver results.
The comparison with financial debt goes even further. Even with technical debt you pay ‘interest’, as long as the debt has not been repaid. In software development, this is the burden of missing parts that have been ‘briefly’ omitted to make speed. With every change or addition to the software, you come across this technical debt again. And just like financial interest, this interest accumulates. The burden also increases when building on top of the technical debt.
More and more technical debt assistance
There comes a point where the debt burden is becoming too great and software needs to be dealt with thoroughly in order to resolve the accumulated technical debt. You reach this point when you notice that you are only trying to keep the existing software working. You no longer need to make any changes or additions. So your ability to pay interest then comes to the fore.
Lately, the help of our software engineers has been called upon more and more for this technical debt assistance. These are often much needed, but difficult processes. Paying off technical debt means making investments, without the client noticing that something is changing in his application. No new functions are added that benefit users. The application will become healthy again. After that, capital is released again - which was previously spent on interest - to change or expand the application.
Deliberately choosing guilt
In itself, building up a little technical debt in software development is a normal course of action, especially in new-build projects. However, it is crucial that this is done very consciously and explicitly. And that often does not happen! Our software engineers consciously take clients into account, but we prefer to avoid the build-up of technical debt altogether. Making the choice should not be an autonomous decision of the software engineer, but one that is taken together with the client.
It is mainly a business consideration and not a technical one. The business consideration is to move work forward to achieve earlier business results. But in the knowledge that overtaking that work will cost more money later on. And the later that becomes, the higher the costs. This is often not considered at the time of decision. That’s when speed counts.
Every application has hidden guilt
Making conscious and explicit choices means above all naming and quantifying ‘the guilt’. Often in man-days of work needed to straighten cut corners. During software development, keeping a ‘technical debt list’ is a must for every project. Pay attention to whether this also happens with your software development.
It is not only a must, but also a luxury to have an up-to-date and complete list of the technical fault in an application. Virtually every application carries this with it and without a complete list the challenge is to get the debts to surface. To solve them afterwards as much as possible. So that at least the debt doesn’t increase again. With our digital debt assistance, our software engineers help applications get back on track.
Also with beta software take the technical fault into account. Because you often see it, especially with software-as-a-service (SAAS) companies: that icon next to product name or logo with the label: Beta. This actually means that the software is not finished at all. Important items or components are still missing and have not been tested properly. In that case, there is most likely a large technical debt list.
These are very deliberate decisions of those software companies. They can put their product in the hands of users very early on. And they help to make the product better. Meanwhile, software developers have some time to clean up the source code and get rid of the technical guilt. You can choose to do that, but do it consciously.
Always pay off the debt
As an organization, you could also decide not to pay off the debt. For example, because the interest ‘doesn’t seem to be that bad’. But how good is your view of the debt burden and the consequences? Practice shows that the real pain of technical debt is only felt when an application needs to be adjusted. Then the previously cut corners are often already forgotten. And then comes the surprise that simple adjustments are suddenly very complex and take ‘a lot of time’. My advice is therefore: repay that debt!