Technical Debt, Agile, and Sustainability
In this post, we explore how to address technical debt more sustainably. Technical debt can cost organizations time, money, customer relationships, or, in worst-case scenarios, their entire business. What’s more, it’s probably happening at your organization and you may not even realize it.
When Your Website Needs an Intervention
This website is like an episode of Hoarders.
The developer’s words stung, but he was right. After years of quick edits, Band-Aid fixes, staff turnover, and countless software patches, managing the company website was a painful and time-consuming process. The front-end was slow-to-load, while anyone making site updates faced a frustrating, time-consuming admin experience with countless workarounds.
Sound familiar? Poorly managed websites and other digital products cost organizations time, money, and frustration every year. If effective digital product management or good governance practices aren’t prioritized and properly resourced within your organization, you will run into these issues. It is only a matter of time.
What’s worse, when faced with these challenges, many organizations choose to ditch their failing software and start over from scratch. Before long, the cycle begins again. However, a complete website redesign every few years isn’t always the answer. There are more sustainable ways for your organization to approach this.
Most importantly, slow products and increased error messages are usually just the tip of the technical debt iceberg. If left unchecked, these issues can take down entire systems. For example, over the course of a single day in 2015:
- A computer glitch grounded all domestic United Airlines flights.
- The New York Stock Exchange went down.
- The Wall Street Journal’s website was offline.
This all happened one day after Chinese stocks took a massive tumble. Later, it was called The Great Technical Glitch of 2015. While some discounted the significance of these events happening concurrently, this day drove home the point that our software systems—which we use to run our organizations and, increasingly, our lives—are very vulnerable.
Whether it’s the company website or a financial system that runs your entire operations, technical debt-related issues occur every day. Let’s explore what technical debt is, why it happens, and some things we can do about it.
What is Technical Debt?
Technical debt (also known as tech debt or code debt) describes what results when development teams take actions to expedite the delivery of a piece of functionality or a project which later needs to be refactored. In other words, it’s the result of prioritizing speedy delivery over perfect code.— Product Plan
As noted above, many organizations struggle to maintain digital products and services over time. People get busy. Other organizational priorities take precedence. Product teams deliver features at breakneck speeds. Sometimes, it’s just easier and more cost-effective to take shortcuts:
- Your product team delivers a rough feature to make a sprint deadline, but doesn’t refactor the code to make it production-ready.
- The marketing team installs several plugins to quickly add website functionality, not realizing that those plugins cause conflicts and need regular maintenance.
- Agencies use pre-built themes or “page builders” to quickly create websites that meet a client’s restricted budget, usually at the cost of speed, performance, security, and sometimes long-term viability.
Unfortunately, this patchwork approach to managing digital products leads to instability:
- Features load slowly, don’t load at all, or don’t work as expected, which confuses users and causes them to leave forms unfinished, abandon shopping carts, or close accounts altogether. Slow performance and poor user experience also adversely impact search results.
- Product administration is confusing, significantly increasing the time it takes to add new features or content, train admins, and manage the product.
- Over time, when software conflicts and incompatibilities are left unchecked, digital products become targets for hackers, leaving your product and customers’ private data at risk. With new privacy regulations like GDPR and CCPA, exposing user data could lead to large fines.
This is technical debt. It’s an annoyance for some, a potential catastrophe for others. And it happens more often than most people realize.
How Does Technical Debt Happen?
A lot of new code is written very very fast, because that’s what the intersection of the current wave of software development (and the angel investor / venture capital model of funding) in Silicon Valley compels people to do…Software engineers do what they can, as fast as they can. Essentially, there is a lot of equivalent of “duct-tape” in the code, holding things together. If done right, that code will eventually be fixed, commented (explanations written up so the next programmer knows what the heck is up) and ported to systems built for the right scale — before there is a crisis. How often does that get done? I wager that many wait to see if the system comes crashing down, necessitating the fix. By then, you are probably too big to go down for too long, so there’s the temptation for more duct tape. And so on.— Zeynep Tufekci, Why the Great Glitch of July 8th Should Scare You
While technical debt often accrues because of poor development practices, developers are rarely to blame. Technical debt is most often the collective result of bad product management decisions made over time by many stakeholders. It is an organizational change management issue, not simply the purview of your IT department or web development team. It impacts everyone.
Here are several common ways increased technical debt can occur:
- A project mindset versus a product mindset leaves products under-resourced and undermines long-term viability. Without proper resources in place over time, things break.
- Organizations move quickly in the name of being agile without understanding the long-term consequences. More on that below.
- Teams don’t consider a wide enough range of stakeholders when creating digital products, resulting in unintended consequences as the product evolves or scales.
- Sometimes, organizations simply don’t have the budget or resources necessary to effectively reach their goals, causing them to cut corners as a result.
Agile Methods and Technical Debt
If we continue to move fast and break things, we are likely to break something important.— Greg Satell, Harvard Business Review
“Move fast and break things,” a phrase made famous by Facebook’s Mark Zuckerberg, is a popular mantra for digital product teams. In the name of “innovation and disruption”, teams often use Agile practices to bring new ideas and features to life quickly. Agencies and internal product teams use these methods to accelerate project deliverables, cut costs, and quickly test new features.
Mightybytes advocates for using Agile methods to build digital products and services. Over the years, adopting these methods addressed so many problems that arose from outdated waterfall practices. On a waterfall project, extensive up front planning—often in the form of a problematic RFP process—sets projects up for failure from the start.
However, we are not Agile (capital ‘A’) purists. Like many companies (and most agencies), we adopt what will work for our clients and our business model while adjusting practices to fit our unique needs. Regardless, an Agile-ish approach is still leaner, more efficient, and can be more sustainable long-term.
Unfortunately, this mad dash to Agile is not without its own set of problems. If you’re not careful, you might easily fall into some of the traps mentioned above.
Sustainability Pitfalls in Agile
Scaling Agile methods focusing on internal concerns misses the point of business agility. Responsive businesses must focus on deeply understanding customers and how to deliver to them consistently.— Inés Almeida, Scaling Agile is not the Path to Business Agility
Let’s look at the sustainability implications of improperly adopting Agile methods. If yours is a physical product, the road from MVP to fully realized product could be filled with waste, as shown in the image above. The same goes for digital products:
- In addition to frustrating users and increasing churn, slow products waste more energy than their lean, efficient counterparts. This contributes to the estimated 1.6 billion tons of greenhouse gas emissions that the internet releases every year, not to mention your organization’s own digital emissions.
- Obsolescence—often the result of rapidly adopting new technologies or intentional product strategies—can lead to billions of tons of e-waste.
- If your agile team moves fast and breaks things, there could also be unintended social consequences. Related, sometimes a technology solution isn’t the best answer to a problem.
All of these things undermine successful sustainable digital strategies. Compounding this, as noted by the quote above, technical debt increases exponentially in larger organizations where hundreds or even thousands of people contribute to digital products and services each day. This fact is rarely considered in company sustainability efforts.
So, how might we fix these issues?
How to Address Technical Debt
Confusion is the enemy of productivity and there seems to be no shortage of confusion in the Agile way. When you have non-technical people dictating technical things it rarely works out well.— Sam Redmond, Why Agile Will Continue to Fail
Technical debt is one of the most common and often overlooked aspects of long-term digital transformation. Left unchecked, it will inevitably alienate your users/customers. In addition, it wreaks havoc on your ability to successfully manage digital products or services over time. Ultimately, it will adversely impact your entire organization.
Here are a few things you can do:
- Let Developers Develop: We appreciate good collaboration. However, sometimes it is more appropriate for product stakeholders to stay in their lane. Give your development team the space they need to do their best work.
- Flexible Contracting & Budgeting: Reserve enough time and money to thoroughly test new features and content. Be flexible with budgeting so that a necessary pivot won’t put the project at risk, or worse, bankrupt your organization.
- Rigorous Testing & QA: Build in the necessary time and resources to thoroughly test all features as part of a product’s release schedule.
- Audits & Refactoring: If you use Agile methods, build time in for regular audits to address technical debt, performance, accessibility, and so on. Those audits can also inform code refactoring.
- Product Management: Good product management practices will help you focus on desired outcomes with target users over a list of rapidly-developed outputs or unproven features.
- Prioritize Sustainability: Use sustainable web design techniques to prioritize efficiency, performance, and reduce waste and energy use.
- An Agile Mindset: Focus on the tenets of organizational agility—collaboration, communication, testing, continuous improvement and learning—while also prioritizing productivity (see the point about developers developing above). Remember, agile (small ‘a’) should be a mindset within your organization, not necessarily a strict, prescriptive set of rules.
- CDR: Adopt corporate digital responsibility (CDR) practices to ensure that your digital products and services align with your organization’s larger ethics and responsibility goals. This can help address risk and unintended consequences before they occur.
- Failure is Your Friend: With continued experimentation, failure is inevitable. It is also your best teacher. Embrace it. Make sure your team also understands that failure is a natural part of continuous learning.
- Know Your North Star: Finally, your entire team should understand the organization’s mission and feel empowered to make decisions within the guardrails of that mission.
A Debt-Free Future
Debt is something we owe in the future. Debt is contrary to any sustainable system. It is contrary to a sustainable economy. It’s contrary to a sustainable household budget. It is contrary to a sustainable use of resources.— Mark Reeves, Sustainable UX
Following these guidelines won’t ensure that you successfully address every potential hiccup, roadblock, or technical debt-related issue within your organization. However, by reviewing, resourcing, and regularly addressing broader stakeholder needs, reducing technical debt will become easier. You’ll foster better relationships with customers, your team, and the planet.