The Human Cost of Tech Debt
Editorial Note: I originally wrote this post for the Infragistics blog. Head over to their site and check out the original. While you’re there, have a look at the other blog authors and their product offering.
If you’re not already familiar with the concept of technical debt, it’s worth becoming familiar with it. I say this not only because it is a common industry term, but because it is an important concept.
Coined by Ward Cunningham, the term introduces the idea that taking shortcuts in your software today not only means paying the price eventually — it means paying that price with interest. In other words, introducing that global variable today and saving half a day’s work ahead of shipping means that you’re going to pay for it with more than half a day’s labor down the line.
The Power of the Metaphor
I’ve spent significant time doing IT management consulting in recent years, after spending years and years writing code. And I can tell you that this metaphor for shortcuts in the codebase is a powerful one when it comes to communication between the business and the software development group. When you explain software decisions to managers and MBAs using the language of economics, they get it.
Because of the metaphor’s power and subsequent effectiveness for business concerns, it is often used to describe the health of projects, particularly vis a vis deadlines and milestones. The developers may communicate that an aggressive deadline will result in technical debt, making features in the future take longer to ship. Analysts and project managers might account for technical debt when discussing slipped deadlines. IT upper management might ask for an assessment of the amount of technical in an application when making a strategic, replace/retire/rewrite decision.
The problem of technical debt is for most people, in essence, a problem of time to market.
But I’d like to talk today about the human side of the problem. And, make no mistake — in business, all human problems are also business problems,viewed with a wide enough lens. Unhappy humans are unhappy workers, and unhappy workers are less productive. Yet, this angle of technical debt is seldom discussed, in my experience.
For a manager, a code base high in technical debt means that feature delivery slows to a crawl, which creates a lot of frustration and awkward moments in conversation about business capability. For a developer, this frustration is even more acute. Nobody likes working with a significant handicap and being unproductive day after day, and that is exactly what this sort of codebase means for developers.
Each day they go to the office knowing that it’s going to take the better part of a day to do something simple like add a checkbox to a form. They know that they’re going to have to manufacture endless explanations for why seemingly simple things take them a long time. When new developers are hired or consultants brought in, they know that they’re going to have to face confused looks, followed by those newbies trying to hide mild contempt.
To tie this back to the tech debt metaphor, think of someone with mountains of debt trying to explain being harassed by creditors. It’s embarrassing, which is, in turn, demoralizing.
Not surprisingly, this kind of situation tends to lead to bickering among the team. Again, the metaphor holds as one would expect this kind of behavior from a married couple with crippling debt. Teams draw battle lines.
It might be the aforementioned newbies against the tenured staff upon whom they blame the problem. It might be the maintenance programmers versus the developers or the people on the green field project versus the people responsible for the legacy beast in which the tech debt resides.
Whatever those lines may be, they become real and they become problematic. They add acrimony on top of the frustration and embarrassment of the problem itself.
As embarrassment mounts and the blame game is played more vigorously, team members can feel their professional relevance slipping away. After all, tech debt creates substantial drag not only on feature development, but on the general evolution of a codebase.
In these sorts of codebases, everything becomes difficult. Teams postpone upgrading to the latest version of the language. They resist incorporating modern architectural and design practices. They fear to replace outdated third party add-ins with modern ones. Generally speaking, they want to touch things as little as humanly possible, because doing so further impairs their already lethargic process. It’s too slow and it’s too risky.
The Hidden Business Cost: Turnover and Attrition
Hopefully it should be obvious to management that unhappy developers is a business problem and a serious one at that. In the current IT market climate, developers have options — even ones stuck on a legacy codebase with crippling tech debt.
Coming to work each day to work in a tortured code base, with disgruntled people, and with a mounting sense of irrelevance creates a team full of people that are going to be open to other options. And, sooner or later, they’re going to start leaving, and the ones leading the charge will be the ones the organization can least afford to lose. It will become harder and harder to hire into the group and it will take longer and longer for those who do come in to be productive.
So when you think of tech debt, don’t think only in terms of the business problem of delayed features and rising defect counts. Think of the human cost, and the much more serious, much longer term business problem that results.
Editorial Note: This post was later referenced here, at DevIQ.
Want more content like this?
Sign up for my mailing list, and get about 10 posts' worth of content, excerpted from my latest book as a PDF. (Don't worry about signing up again -- the list is smart enough to keep each email only once.)