Happier devs, happier users (pay that tech debt!)

Paying off tech debt, much like clearing out clutter in a workspace, creates a smoother path to dev productivity and, ultimately, user satisfaction. But to fully grasp this, let’s discuss what tech debt is and why it’s created in the first place.

What is Tech Debt?

It was introduced by software developer Ward Cunningham, refering to the implied cost of additional rework caused by choosing an easy solution now instead of using a better approach that would take longer.

To put this simpler.

Imagine building a house. You might temporarily use cheaper materials to meet your deadline, but over time, these materials degrade faster, leading to higher maintenance costs.

Similarly, in software development, tech debt represents the future costs incurred due to current shortcuts or suboptimal code practices.

Why is Tech Debt Created?

Tech debt accumulates for several reasons. Often, it’s the result of tight deadlines where the focus shifts to immediate delivery over perfect code.

Sometimes it’s due to technical constraints or limitations in existing technology, leading developers to implement less-than-ideal solutions. Other times, it’s simply the result of evolving project requirements. As a project grows and changes, code that was once fit for purpose may no longer be adequate, leading to patches and fixes that pile up.

Returning to our original scenario, consider the impact of tech debt on a simple task like adding a new screen to an app. Without addressing the underlying debt, this task becomes disproportionately challenging, leading to questions like, “How do I add this without breaking everything?”

The challenges don’t stop there. Onboarding new developers into a project clogged with legacy systems and complex, tangled code can be a nightmare. It’s not just time-consuming; it’s a frustration that can dampen the enthusiasm of even the most eager developers.

We can do better.

Now, let’s reimagine this scenario with a focus on refactoring and addressing tech debt early. Do no think about taking a detour from immediate goals like feature delivery or bug fixes. Instead, you’re paving the way for a series of positive outcomes:

  1. Efficient feature delivery: A streamlined codebase allows for the quick addition of new features, meaning updates and new functionalities can be rolled out faster and more reliably.
  2. Enhanced user experience: Freed from the burdens of tech debt, developers can focus on improving the app’s user interface and overall experience, leading to greater user satisfaction.
  3. Rapid bug fixes: A cleaner codebase simplifies identifying and fixing bugs, directly benefiting the user experience.

The domino effect of addressing tech debt is evident: clearing it leads to happier, more productive developers, which in turn results in faster feature delivery. And when features are delivered efficiently and effectively, the ultimate winners are the users.

Paying off tech debt leads to happier developers, which in turn results in faster feature delivery and happier users.

While the immediate benefits of tackling tech debt might seem intangible, the long-term advantages are substantial. By investing time in refactoring, you’re not just enhancing your code; you’re building a foundation for a more efficient and sustainable development process.

Rome wasn’t built in a day

In addressing tech debt, it’s important to recognize that not all solutions require grand, sweeping changes. Sometimes, the most effective approach is to make small, incremental improvements – a concept encapsulated by the Boy Scouts rule.

This rule, inspired by the Boy Scouts of America’s principle of leaving the campground cleaner than you found it, applies elegantly to coding. It suggests that whenever you touch a piece of code, you should leave it a little better than you found it.

This philosophy encourages developers to make minor improvements each time they work on a part of the system. These could be as simple as:

  • renaming a poorly named variable
  • breaking down a function that’s doing too much
  • refactoring a small section of code for readability.

The beauty of this approach lies in its practicality. Instead of setting aside large blocks of time for a massive refactor, which can be daunting and disruptive, developers can continuously and gradually improve the codebase.

This method of incremental improvement has several advantages. It’s less risky compared to large-scale refactors, as it minimizes the chance of introducing new bugs. It’s also more sustainable, as it becomes a part of the daily development routine rather than an occasional, large-scale event. Moreover, it fosters a culture of continuous improvement among the development team, with everyone contributing to the health of the codebase in their everyday work.

By making small, consistent improvements, you not only maintain a healthier codebase but also pave the way for easier, more substantial changes in the future. Thank’s to this approach you’ll make sure that addressing tech debt won’t be overwhelming. It will become natural, ongoing process integrated into the rhythm of regular development work.

Making constant refactoring a part of your development team’s culture is a strategic investment in the resilience and agility of your team.

Encouraging constant refactoring as part of the team’s culture involves valuing continuous improvement. It requires commitment from both the leadership and the team members.


Jarosław Michalik

Mobile dev consultant & Google Developer Expert in Kotlin

With over 7 years of experience in mobile development I help my clients untangle complexities of legacy Android projects.

Read also