Building amazing mobile apps and cutting-edge web applications involves pushing the limit of what's possible. It also involves trade-offs. Sometimes developers have to make a call to fix something at a later date to meet a deadline. These are mostly small items that users won't notice — but these lists of "to-do's" add up over time into what's called technical debt.
Different teams have different descriptions for these lists. Some call it design debt, code debt, or performance debt. We define technical debt as the implied cost of additional rework caused by choosing a band-aid solution in the present instead of using a better approach that would take longer.
Last-minute changes, ongoing development on a long project, business pressures, lack of process and documentation, delayed refactoring, and poor communication can all cause the build-up of technical debt. Ultimately, changes required that are not completed are considered debt, and until paid, will incur interest on top of interest, making it cumbersome to build a project.
This debt shows up in problematic ways, said Joe Reda, BitBakery's CTO. "As debt increases and your product use increases, you end up with more and more cases where you get customer complaints, server crashes, missed deadlines and more."
When things pile up, tackling debt is probably the last thing on your list of fun things to do, but what if you found a way to change that?
One of our clients tackles technical debt with an internal competition. For one week, the team breaks from regular work to spend focused time on performance debt projects. This mini-hackathon helps speed up parts of the project they've identified as problem areas. The team to perform the most tasks wins a prize, getting people excited about tackling what could be a tedious, overwhelming task.
They refer to it as Competition Week, and we think it's a great, creative way to solve technical debt. A few of our developers who support the client as an embedded team even get to participate.
We've put together some of our tips on how to manage technical debt:
Communicate clearly and consistently
Much like monetary debt, the longer you leave technical debt unpaid, the harder it is to dig yourself out of the pit.
Our advice: Flag technical debt issues up to your team clearly and often.
Everyone is prone to mistakes, forgetting things, or getting blocked on a project. What makes it worse is not bringing it up and continuing to try to work around it as the problems build up.
Try to facilitate awareness and accountability for technical debt by making technical debt part of every conversation with your developers. Our team brings up issues during daily stand-ups, retrospective meetings, and catch-ups where it is feasible to do so.
In these meetings where people jump into brainstorming, BitBakery's Product Manager Diana Valdes advises it is best to "encourage team members to write possible solutions down and record them as a detailed maintenance ticket as soon as a possible solution comes up." This ensures that no issue or solution gets lost and is an excellent tool for visibility and control over technical debt.
Code smart from the start
You can avoid the build-up of technical debt by ensuring your team uses good coding practices from the start. Good code should be easily editable and testable. Organized, clean, and readable code will also help create exceptional developer and technical onboarding processes.
We all know there's the right way to do something and the quick way to do something. In some cases, the quick way is the right way (to avoid over-engineering). In other cases, a team will intentionally do something the "wrong" way to deliver a product to the market quickly.
If this is the case, be sure you track not only how much time you'll save on launching but also what it will take to repay the technical debt and how to incorporate clean-up time into your development cycle to stay on top of your debt.
Find small ways to rework along with feature requirements
Technical debt can be like a box of oily rags just waiting to catch fire when creating new features in production. The catalyst? Delayed refactoring.
Adding a few lines of code here or there to fix a bug or add a new unplanned feature is a common thing. It then accumulates, your codebase becomes messy, and, eventually, you'll have to restructure the code to make it orderly. The longer refactoring is delayed, and the more code is added, the bigger the technical debt.
To solve this problem, Valdes says to try the 80-15-5 rule. "Every sprint you do, try to focus 80% of production on new features, 15% allocated to architectural changes to make the process better, and 5% on percent bug fixes."
Setting aside consistent time to consider refactoring will cause the feature delivery to take longer, but it will gain the time back in better software stability. This compromise requires immense transparency within your development team, so be sure to focus your efforts on our first point – clear communication.
Institute code standards and reviews
Another technique for technical debt is testing and code reviews. As critical as testing for the software development process is a culture of code reviews. No matter how much and how rigorous testing you conduct, an independent fresh look can help spot missed typos, bugs, edge cases, etc.
To set yourself up for success, Reda suggests having clear goals in mind for tackling your debt. Like financial debt, you have to plan pay-off periods to reduce your project's technical debt. Paying off your technical debt means scheduled days, hours, or even a week-long competition when the team is doing the clean-up.
"Pick out the paths that are causing the most problems, and be sure to review the performance of your clean up to ensure your focused work is giving you the results you're aiming for."
Technical debt is a part of life, and a little debt can even be beneficial when managed strategically. What's important is to be conscious of the technical debt to ensure your product's long-term agility and health.
Managing your technical debt has the added benefit of fostering better communication, empathy, and transparency between product and engineering, making happy customers and a productive development team.
Is technical debt slowing down your team? We can help. When you work with our team, we make addressing technical debt an organizational value across your product and development teams to help take control of your technical debt. Contact us today!
Photo by John Schnobrich on Unsplash