Analysts at Gartner have identified seven types of system modernization that can be undertaken:
- Rehost: Lift and shift to a new platform.
- Replatform: Make minor adjustments to leverage cloud benefits.
- Refactor: Rearchitect the application.
- Rebuild: Rewrite the application from scratch.
- Replace: Swap the application with a new one.
- Retire: Decommission the application entirely.
- Retain: Keep the application as-is.
We are not going to dig into each of these approaches here, but will discuss the implications of one of them in a bit of detail. Namely, the first one on the list, rehosting.
Rehosting—often called lift-and-shift—can seem to be attractive especially because it appears to offer a quick path to modernization. The application is moved to a new platform with relatively few code changes, allowing organizations to avoid a complete rewrite. On paper, it looks like it reduces risk, shortens schedules, and preserves existing business logic.
The problem is that lift-and-shift frequently changes where an application runs without fundamentally changing or improving how it runs.
A legacy application designed decades ago carries with it the architectural assumptions, design decisions, and technical debt of its original environment. Simply moving it to a different platform does not eliminate inefficient algorithms, tightly coupled code, obsolete interfaces, or poorly designed data access. Instead, those characteristics are transported to the new platform where they often become more expensive to operate.
Another limitation is that lift-and-shift rarely takes full advantage of the capabilities of the target platform. Modern cloud platforms offer elasticity, containerization, orchestration, event-driven architectures, managed services, and automated scaling. Applications that were merely rehosted generally cannot exploit these capabilities because they were never designed to do so. Organizations often discover they are paying cloud prices while continuing to operate applications as though they were still running on their original infrastructure.
Performance can also suffer. Legacy applications frequently depend on architectural characteristics of the original platform. Mainframe applications, for example, were written assuming extremely fast I/O subsystems, high-throughput transaction processing, shared data management, and sophisticated workload management. Moving those workloads elsewhere without redesign often increases latency, introduces network overhead, and creates additional synchronization challenges.
Operational complexity frequently increases as well. Rather than simplifying the environment, organizations may end up supporting the original application architecture while simultaneously learning an entirely new operational platform. Monitoring, security, backup strategies, disaster recovery, automation, and performance tuning all must be reestablished, often without delivering proportional business value.
Perhaps the biggest drawback is that lift-and-shift postpones modernization rather than accomplishing it. The application still requires ongoing maintenance, the code base continues to age, and future modernization projects remain necessary. In many organizations, lift-and-shift becomes an expensive intermediate step that delays the inevitable architectural improvements.
That is not to say rehosting is never appropriate. It can make sense when:
- Existing hardware is being retired.
- Data center consolidation is required.
- There is an urgent need to relocate workloads quickly.
- The application is stable and expected to have a relatively short remaining lifespan.
- The move serves as the first phase of a broader modernization roadmap.
The key is recognizing that rehosting is an infrastructure strategy, not an application modernization strategy. It changes the execution environment but typically leaves the application’s architecture, design, and technical debt largely intact. For that matter, replatforming is not much better, but it at least acknowledges that changes should/will be made to accommodate the new platform.
For mission-critical mainframe applications, rehosting is fraught with potential peril. Indeed, many organizations discover that the greatest business value comes not from moving proven applications, but from modernizing around them—exposing APIs, integrating with cloud services, enabling AI and analytics, automating deployment, and enhancing user experiences while preserving the reliability, security, and transactional integrity that made those applications valuable in the first place. That approach delivers modernization without discarding decades of proven business logic.
