Editor’s note: The following is a guest post from Kirat Sekhon, head of technology at Thomson Reuters.
It’s not just global economies that have amassed a staggering amount of debt in recent years. Enterprise technology departments of the world’s largest corporations have rapidly accumulated debt of a different kind.
Technical debt is the result of decades of shortcuts, software patches and deferred maintenance to enterprise technology infrastructure that takes place when companies prioritize speed-to-market over rigorous, carefully choreographed infrastructure development.
The last several years of digital transformation, capped by the recent growth of generative AI and expanded use of large language models, has pushed legacy tech stacks to the limit. The CrowdStrike global IT outage, high-profile cybersecurity attacks and glitches in critical air traffic control systems are symptoms of the underlying problem.
How and when businesses choose to address underlying issues could rearrange the ranks of today’s tech leaders and laggards.
The set-it-and-forget-it mindset
The moment a piece of code is written, it immediately has tech debt. Things move fast, and any update to an existing configuration is a product of its time and place, one that is heavily influenced by the prevailing best practices.
For example, most code bases developed by major technology companies 10 to 15 years ago were designed using a monolithic architecture.Originally housed on local servers, these systems were challenging to modify because any small change in one function would create ripple effects throughout the rest of the code base.
Because these systems were expensive to create and hard to update in real-time, the prevailing business mindset throughout the early 2010s was to set-it-and-forget-it until it was time to introduce a major new software upgrade.
More recently, as most major business functions have migrated to the cloud and software engineering has evolved, the prevailing sentiment among programmers has been to transition to a microservices architecture.
In the new paradigm, software is developed in small, independent components or services that perform a single function and communicate with other services through a common interface. This approach allows individual services and functions to be modified on an ongoing basis.
So, why doesn’t everyone just adopt a microservices architecture and call it a day? Because, in the real world, businesses need to keep running, delivering uninterrupted service while these major structural changes to the underlying technology infrastructure are being made.
As a result, many companies end up in a place where they have one foot in each world, with some functions running on legacy architecture and others running on new, more agile systems – and patches and workarounds keeping everything tied together.
But, over time, that juggling exercise will catch up with them.
Observability is key to modernization
For businesses operating in the messy middle, it is possible to manage the transition incrementally. However, the approach requires a careful balance between ongoing maintenance and major structural change.
The key to navigating that balancing act is observability. The ability to monitor software performance in real-time is the single most important investment businesses can make to address a build-up of technical debt.
For many companies – particularly those relying on legacy technology without built-in scalability testing and performance metrics – the early warning system consisted of customers calling in with problems. At that point, tech teams have no option but to get into firefighting mode to patch the immediate problem.
With observability built into the architecture, however, tech teams are able to spot developing issues before they manifest into full-fledged emergencies, giving themselves time and options for how best to address the problem.
Having this level of visibility into system performance also becomes critical when implementing and updating new microservices, because teams will be able to spot and remediate potential communication issues before they ripple through the entire codebase.
As critical business functions depend on solid tech infrastructures and the pace of digital transformation accelerates, software agility will only become more important. Likewise, the consequences of failed software updates will become more dire for companies unable to anticipate and react to problems in time.
