Get Puppet Enterprise First 10 nodes are free!
Try it now
Request a demo
Automate IT and infrastructure, manage complex workflows, and mitigate risk at scale.
Try the full-featured Puppet Enterprise for free on 10 nodes.
Puppet Comply Find and prevent compliance failures
Compliance EnforcementRemediate to stay in compliance
Continuous Delivery for Puppet Enterprise Build, test, and deploy infrastructure as code faster and easier
Content & Modules Pre-built scripts to automate common tasks
CentOS EOL Here’s how to secure your CentOS infrastructure – even after EOL.
Find thousands of component modules built by the community and guidance on using them in your own infrastructure.
Visit Puppet Forge >>
Open Source PuppetPerfect for individuals and small infrastructure
BoltAutomate tasks in orchestration workflows
See all open source projects >>
Contribute to open source projects >>
Tech debt affects just about every software organization. For better or worse, speed is one of the core tenets of the software development industry – the rush to build more, add new features, and find solutions fast can drive short-term growth for small organizations and add value for large companies. But haste, as it usually does, makes waste: The mass of suboptimal code, redundant services, and bottlenecked processes that we call tech debt.
You’re probably affected by some amount of tech debt in your daily responsibilities, whether you’re a developer, IT ops professional, or even a user of technology produced by those teams. Let’s take a look at what tech debt does to a software development team, how it happens, best practices for reducing tech debt now, and what you can do to reduce tech debt in the future.
Tech debt is the gradual accumulation of low-quality code, redundant services, and bottlenecked processes in software development. Tech debt is often caused by rushed work and tight deadlines. Shortcuts in coding might improve your velocity in the short term, but they require costly maintenance and fixes later on.
The consequences of tech debt can range widely, from decreased efficiency all the way to security vulnerabilities. Tech debt can introduce bugs, slow down users, impact system reliability, make it hard to scale up and accommodate more traffic/usage, and be a drag on team morale (which makes all those other problems worse).
Developers are incentivized to build solutions that will meet business objectives on time, even if it’s not made for the long term. When it achieves the business objective, it usually gets forgotten and built onto – until it becomes a problem. But because software development moves too quickly for thorough review and refactoring, it’s easy for tech debt to pile up fast without being noticed.
A few common causes of tech debt include:
Worse yet, every new instance of tech debt makes it harder to reduce the tech debt you already face. To reduce tech debt, your team would need to spend valuable time cleaning up all that old, suboptimal code instead of writing new code that contributes to your organization’s profit-driven bottom line. You can see how that would add up to a bit of a vicious cycle.
Tech debt can be a huge DevOps blocker. Tech debt leads to reduced agility, higher fail rates, difficulty scaling DevOps, decreased security and compliance posture, and more.
Technical debt slows down teams, decreases productivity, and creates bottlenecks. Those lead to team-wide inefficiencies, security risks, compliance errors, and a terrible developer experience. It affects many levels of a DevOps organization, from developers and DevOps engineers all the way up to business leaders.
In a DevOps context, you could say that tech debt makes DevOps harder to do – and conversely, DevOps can be one of your greatest assets in kicking tech debt. The core tenets of DevOps are focused on the kinds of problems that lead to tech debt, like poor planning, inadequate testing, scope creep, and duplication of work.
By the time you notice tech debt, there’s not really time to uproot everything and fix it then and there. Even if there was time, it’d be way too risky to roll out code changes to your underlying infrastructure willy-nilly. (That’s how you got all that tech debt in the first place, remember?)
No, that won’t work. If you want to reduce tech debt in your organization, you’ll have to get disciplined and proactive about it.
The hard part about tech debt is that it slowly becomes normalized, which leads to it becoming part of the status quo, sort of like background noise. In fact, your developers probably stumble over it all the time in the course of regular software development – but they accept that it’s just ‘the way we do it’ or a ‘necessary’ part of the process.
The best way to surface the most painful tech debt is to conduct code reviews. Be on the lookout for telltale signs of tech debt:
For example, not long ago I ran into a function named capitalize(str). Except it didn’t capitalize the string. It actually lowercased it, replaced some characters with underscores, removed other characters, and various other transforms. It was complex and had strange nested conditionals.
After a bit of spelunking, I determined that it was actually normalizing a string into a GitHub username. My best guess was that it had been repurposed and then evolved over enough time that it no longer resembled what it started as! I didn’t have time to unwind the conditionals and simplify the strange logic, but I renamed the function to normalizeToGithub(username) and now it was clear what it was being used for (and it will be far easier to search the codebase next time we want to refactor!)
Once you know where tech debt hides, take the appropriate action to correct it. Refactor code, document changes, and share what you find with the rest of the development team.
Obviously, the best way to fix tech debt is to avoid falling into that trap altogether. But it’s a slippery slope, and one that’s easy to find yourself at the bottom of. It turns out that the principles of DevOps can help you fix and prevent tech debt.
The best way to prevent tech debt is to set up regular code reviews, automate testing and scanning, and use infrastructure as code. Those tactics will help reveal tech debt before it becomes a burden and make it easier to handle in the future.
In a perfect world, you’d have the time to go back and fix all the old code that’s leaving you stuck with a bunch of tech debt. Congratulations! Everything’s better now. Except… now you’ve got to make sure it doesn’t happen again!
In fact, reducing tech debt is only the first step toward keeping code clean. Tech debt prevention might seem like a pipe dream, but it’s possible if you’re able to commit to it.
It’s important to remember that for most organizations, tech debt is inescapable. In fact, it’s often accumulated intentionally the same way you might take out a loan to purchase a house or car today instead of saving for years and then paying a mountain of cash. But while you might not be able to prevent a bit of cruft from getting through here and there, you can manage and mitigate it before it becomes insurmountable. Keep tech debt on a short leash and you can prevent it from hampering more efficient software development.
Curious how Puppet fits into all this? Puppet’s industry-leading automation is built to make complex infrastructure manageable at scale. Puppet’s agent-based automation works even during network outages, and writing your configurations as Puppet code lets you repeat the same configurations across on-prem, cloud, and hybrid IT.
Check it out for yourself with a free trial of Puppet or request a demo with the Puppet team to see how it helps organizations build, maintain, and manage better systems.
PUPPET TRIAL DEMO PUPPET
Community and Developer Relations Lead, Puppet by Perforce