- Rehost is fastest and cheapest upfront ($500K–$2M); replatform costs 1.5–2x more but cuts operating costs 30–60%; refactor costs 2–3x but owns the architecture.
- Timeline spreads from weeks for simple rehost to 6+ months for large-scale migrations; doing both rehost and modernize together doubles the timeline.
- Many teams end up rearchitecting anyway after rehosting, paying twice; incremental refactoring pays back in 12–18 months versus 36–48 months for full rewrites.
Three Strategies for Moving Off Your Legacy System
A legacy system is one that still runs your business but has become expensive to maintain, difficult to extend, and risky to change. You're stuck between keeping it alive with patches and workarounds (which piles on technical debt) or replacing it. The three main paths forward are rehost (move it as-is to a new platform), replatform (move it and modernize the stack), and refactor (rebuild parts or all of it from scratch). Each has a different cost curve, timeline, and risk profile.
The choice matters. Many organizations eventually end up rearchitecting anyway, effectively paying for two migrations. Knowing which path fits your constraints now helps you avoid that expensive detour later.
Rehost: Lift and Shift
Rehosting means moving your system to a new infrastructure (usually the cloud) with minimal code changes. You take the application as it is—binaries, dependencies, database setup—and run it on new hardware or cloud services.
Cost. Rehost is the cheapest option: a simple database migration runs about $25K, a departmental app around $200K, and enterprise portfolios $2M+. Rehost costs 1x the baseline. For a small system, that baseline might be $100K; for a large one, $2M.
Timeline. Small, simple migrations like a single server application to the cloud might be done in a few weeks or a couple of months; large-scale migrations can take 6 months to over a year. Rehost is faster than the alternatives because you're not rewriting code.
Risk and trade-offs. You keep all your technical debt. The system still runs the same way—slow queries, tight coupling, hard-to-test code paths. Operating costs don't drop much; you've just shifted where you pay them. And the biggest trap: many organizations eventually end up rearchitecting anyway, which means you pay the rehost bill plus a full refactor bill later.
Rehost makes sense if you need a quick win (e.g., your data center is shutting down), the system is genuinely stable and won't need major changes for years, or you need to buy time to plan a real modernization later. It's a temporary fix, not a solution.
Replatform: Move and Modernize Selectively
Replatforming means moving your system to a new platform while also updating the underlying stack—a new database, a new runtime, a new API layer—but keeping the business logic and workflows largely intact. You're modernizing the foundation, not rewriting the app.
Cost. Replatform costs 1.5 to 2x the rehost baseline. So if rehost is $200K, replatform runs $300K–$400K. For enterprise systems, migration costs range from about $500K to several million dollars, depending on system size, complexity, and strategy.
Timeline. Expect 3–6 months for a departmental app, 6–12 months for an enterprise system. Meliá Hotels moved a COBOL mainframe to AWS microservices in 24 months, which is a harder case but shows the real-world range.
Payoff. Replatforming delivers rapid value: often 30–60% reductions in operating costs, improved scalability, enhanced security, and faster feature delivery, while avoiding the extreme risks and timelines of a full rewrite. You also reduce technical debt meaningfully without betting the company on a rewrite.
Risk and trade-offs. You still live with some legacy code and quirks. The integration layer between old and new components can become complex. If your business logic is deeply tangled with your old tech stack, replatforming can feel like you're still fighting the old system. But the trade-off is worth it: faster payback than refactor, lower risk than rehost-then-rearchitect.
Replatform works well when your business logic is sound but your infrastructure is outdated, when you need better scalability or security soon, and when you have the budget for a real modernization but not a complete rebuild.
Refactor: Rebuild from the Ground Up
Refactoring (or rearchitecting) means rebuilding your system with modern architecture, languages, frameworks, and practices. You keep the requirements and domain knowledge, but you write new code.
Cost. Refactor costs 2 to 3x the rehost baseline. A $200K rehost becomes a $400K–$600K refactor. For large systems, you're easily in the $3M–$5M range.
Timeline. Large-scale migrations can take 6 months to over a year or more. Full rewrites often run 12–24 months or longer, especially if you're building concurrently with running the old system.
Payoff. Incremental refactoring payback typically lands in 12 to 18 months versus 36 to 48 months for a full rewrite. You own a clean, modern codebase that's easy to extend, test, and operate. Technical debt is gone. Future features cost less to build.
Risk and trade-offs. Full rewrites are risky. You're building a new system while the old one still runs; if you cut over too early, you miss edge cases. If you run both in parallel too long, costs spiral. You need deep domain expertise on the team, and you're exposed to new tech risk—picking the wrong framework or architecture hurts later. And years of patches and workarounds increase technical debt, making legacy modernization more complex and expensive.
An incremental approach—refactoring feature by feature or module by module—reduces risk and spreads cost. Payback lands in 12 to 18 months versus 36 to 48 months for a full rewrite, and you can start capturing value (faster development, fewer bugs, better performance) as soon as the first piece goes live.
Refactor when your system is unsustainable (too slow, too expensive, team productivity is stuck), when you need significant new capabilities that the old architecture can't support, or when you have the runway and team to do it right.
Cost, Timeline, and Risk Comparison
| Strategy | Relative Cost | Timeline | Operating Cost Savings | Technical Debt | Risk Level |
|---|---|---|---|---|---|
| Rehost | 1x ($25K–$2M+) | Weeks to 6 months | Minimal (5–10%) | No change | Low |
| Replatform | 1.5–2x | 3–12 months | 30–60% | Reduced significantly | Medium |
| Refactor | 2–3x | 6–24+ months | 50–70% | Eliminated | High |
The Hidden Cost Trap: Rehost Then Rearchitect
Here's where many teams go wrong. You rehost to save money and time, planning to modernize later. But later never comes, or it comes on an emergency timeline when the system breaks again. Now you're paying 1x for rehost plus 2–3x for refactor: you've spent 3–4x the cost of doing replatform or refactor upfront.
Doing rehost and modernize at once is where timelines double, so the real trap is delaying the modernization decision. If you know you need to modernize, do it as part of the move, not after.
Generative AI Can Accelerate the Timeline
McKinsey reports 40% to 50% faster timelines and roughly 40% lower tech-debt costs with generative AI, especially during code analysis, documentation, and incremental refactoring. AI-assisted tooling helps you map dependencies, generate test cases, and even assist with translating code between languages or frameworks. This doesn't eliminate the work, but it does compress the timeline and reduce the cost of understanding old systems before modernizing them.
Which Path Should You Pick?
Choose rehost if: Your data center is closing, you need immediate cost savings from infrastructure consolidation, or the system is stable and won't need major changes for 3+ years. Budget 1–2 quarters, plan for rearchitecting in a year or two.
Choose replatform if: You need better scalability, security, or performance; your team can absorb a moderate modernization effort; and you want to cut operating costs without betting everything on a rewrite. This is the middle ground—more cost than rehost, lower risk than refactor, and real payoff in 12–18 months.
Choose refactor if: Your system is strangling your team (slow development, frequent outages, hard to hire for), you need architectural changes to support new capabilities, or you have 12–24 months and a strong team. Accept higher cost and risk upfront for ownership of the codebase and real speed gains later. An incremental approach cuts the risk and lets you validate as you go.
Avoid the trap: Don't rehost with a vague plan to modernize later. If you need modernization, scope it now and do both moves together or choose replatform. The cost of delay is the cost of rearchitecting twice.
At Authect, we often work with teams on the modernization piece—refactoring modules, building new APIs to sit in front of legacy systems, or migrating core workflows to modern stacks. The pattern we see is clear: planning the modernization upfront, even if you rehost first for immediate relief, saves money and chaos down the road.
FAQ
How do I know if my system is truly legacy?
It's legacy when patching it costs more than building new features, when it takes weeks to onboard developers, when infrastructure costs are 50%+ of your budget, when security patches take months to implement, or when you can't scale it to meet demand without a complete rewrite. If three or more of those fit, you're looking at modernization, not maintenance.
Can I do a hybrid approach—rehost some systems and replatform others?
Yes. Many teams rehost systems that are stable and commoditized (old data warehouses, reporting systems) while replatforming or refactoring the systems that drive competitive advantage or need to scale. The key is deciding which systems matter most and sequencing the work so teams aren't stretched thin. Replatform or refactor your bottleneck first—the system slowing down feature delivery or costing the most to run.
What's the risk of picking the wrong strategy?
Picking rehost when you need refactor delays the real work and costs 3–4x as much in the end. Picking refactor when replatform would suffice burns budget and team energy on things that aren't critical. The way to reduce risk is to scope the modernization work early—map dependencies, measure technical debt, understand what needs to change for the next 3 years of business goals—then match the strategy to that scope. A technical audit costs $10K–$50K and saves hundreds of thousands in wrong turns.
How long does the system need to run in parallel during a refactor?
Typically 6–12 months for a complex system. You run the old and new systems side by side, gradually moving user traffic or features to the new one. The longer you run parallel, the higher the cost, so the goal is to cut over in phases. Incremental replatforming or refactoring (one module or team at a time) shortens the parallel window and spreads the risk.
