Software modernization pays off in business agility and tech stack liquidity
Contents
Software modernization is the ongoing work of keeping code on current languages, frameworks, and dependencies. Done well, it lets a business change direction faster, closes known security gaps, and gives developers their time back. Moderne automates that work with OpenRewrite recipes that run across every repository, so modernization becomes routine work for developers and their agents instead of a project every few years.
You only get those benefits if the code stays current, and manual work can’t keep it current at scale. Every application sits on a supply chain of open source libraries and frameworks that release on their own schedules. A large organization has thousands of repositories and far more dependencies than any team can track. Falling behind means missing security patches and bug fixes.
We call the alternative tech stack liquidity: the ease with which an organization can upgrade and adopt technologies across its applications and infrastructure.
Modernization is unavoidable because the software around your code keeps moving.
Even a team that never plans a migration will face one, because the frameworks and libraries under its code keep releasing. Developers keep the code in the current sprint up to date, since that work is visible and small changes are safer, but the dependencies outside the sprint keep moving. Eventually something forces an upgrade: a framework reaches end of life, a critical vulnerability lands, a dependency drops support for an old version, or the business makes a technology decision.
Those upgrades rarely come alone. A major Spring Boot upgrade, for example, pulls in migrations for Spring Framework, Spring Security, Spring Cloud, and the libraries around them.
Security fixes force the same work on a deadline. When Spring4Shell required a Spring Boot upgrade, a mid-sized US insurance provider opened 32 tickets, one per affected repository. Each needed a senior engineer who knew that repository’s version and the steps to reach a secure one, and the work took three weeks and nearly all of the team’s engineering capacity. With recipes doing the upgrade, the insurer now completes a Spring Boot upgrade like that in part of a day, with one developer.
Modernized software lets a business change direction faster.
An up-to-date stack lets teams adopt new platforms and language features when they need them, without first having to finish an upgrade.
Choice Hotels moved more than 500 services from Java 8 to Java 25 in one migration with Moderne, skipping the separate steps through Java 11, 17, and 21. The move gave those services language and runtime features they had been locked out of on Java 8. When the team first weighed skipping versions, the reasoning was simple:
“We looked at the effort to go from 8 to 11 versus 8 to 21 using a tool like Moderne, and we realized it was going to be a relatively similar effort—so we made the bolder move.”
— Stephen Cihak, Choice Hotels (How Choice Hotels scaled Java 21)
Squarespace upgraded more than 200 backend services from Spring Boot 2.x to 3.3 in under a year with Moderne. Its previous Spring Boot upgrade took four years.
Staying current is how teams close security gaps.
Many known vulnerabilities are fixed by upgrading a library or framework. Frameworks past end of life stop getting security patches altogether. A team that can upgrade quickly can close a vulnerability as soon as the fix exists, before attackers get to it.
A global financial services company now fixes more than 100 critical security issues in a single CI/CD run across hundreds of Java services. Remediation that took weeks of coordination between security, development, and QA now takes hours.
Automation changes what modernization costs.
Done by hand, a migration can cost months of developer time, which is why it keeps getting deferred. As teams produce more software, and agents produce it faster, migration has to become an engineering discipline built on automation. A recipe encodes the migration once, and Moderne runs it across every repository and opens the pull requests, so the cost of making the change no longer grows with the number of repositories.
SAP made large-scale refactoring an official business capability, delivered with Moderne. In one case, SAP estimated the work at 60 employee months without OpenRewrite versus 17 with it.
From Developer Pain to Impact: Establishing Large Scale Refactoring at SAP
▶ Watch on YouTube
Automation pays off before any code changes, too. Search recipes show which versions, dependencies, and APIs are in use across every repository, and a dry run of a migration shows what it would change before anything is committed. That’s enough to scope the work and decide where to start. (For a worked example of one complete migration, see the Spring Boot 4 migration guide.)
Coding agents can use the same recipes. Through Moderne, an agent such as Claude Code or Copilot can draft recipes and run them across every repository, then handle the last mile where no recipe fits. The guide on modernizing off of legacy Java app servers shows how that works for moving off WebSphere, WebLogic, and JBoss.
Tech stack liquidity keeps the benefits from wearing off.
A finished migration starts aging the day it completes. Teams that run upgrades as ongoing, automated work keep those benefits instead of rebuilding them every few years. Manual upgrades pull developers away from customer work, while competitors with current codebases adopt new technology first. For more on how teams get there, read From tech debt to tech stack liquidity.
Architecture Modernization Anti-Patterns: The Cost of Good Intentions
▶ Watch on YouTube
To see recipes run on open source code, try the Moderne Platform, or book a demo to see them on your own repositories.
Originally published
