Cloud Computing
Cloud Migration Strategies: The Seven Rs, Discovery, Waves and Cutover
Intermediate10 min readUpdated
A cloud migration is a portfolio problem before it is a technical one. This guide covers discovery and dependency mapping, the seven migration strategies and how to assign one to each application, the landing zone you need before anything moves, data migration and cutover mechanics, and the wave planning and rollback thinking that keeps the programme survivable.
What you will learn
- Run a discovery exercise that produces a usable application portfolio and dependency map
- Assign one of the seven Rs to an application and defend the choice on cost and risk grounds
- Describe what a landing zone must provide before the first workload moves
- Choose a data migration and cutover approach that matches the acceptable downtime
- Plan migration waves with a pilot, defined success criteria and a real rollback path
Most migration programmes are not slowed by technology. The mechanics of copying a virtual machine, replicating a database and repointing DNS are well understood and heavily tooled. What goes wrong is that nobody can say with confidence which of the four hundred applications on the inventory still matter, who owns them, what they talk to, or what happens if one of them stops for six hours. A migration is a portfolio exercise wearing an engineering costume.
This guide follows the sequence a real programme moves through: discover what you have, decide a strategy per application, build the destination, move the data, cut over, and repeat in waves. It assumes familiarity with cloud fundamentals and, where the destination is Azure, with the hierarchy described in Azure fundamentals.
Discovery: knowing what you actually run
Discovery answers three questions per application: what is it, what does it depend on, and what does it cost to keep running as it is.
Automated tooling gets you the first pass. Agentless scanners read hypervisor inventories and network flows; agent-based collectors add process-level detail and performance history. Both AWS and Azure ship migration assessment services that produce a right-sized target recommendation from several weeks of observed CPU, memory, disk and network usage. Take the performance history seriously — it is the single most valuable artefact discovery produces, because it is the only defence against re-provisioning a peak-sized estate in the cloud.
Automation will not tell you the things that decide the plan: who signs off downtime, which vendor contract forbids running outside a named data centre, which database is quietly the system of record for a regulatory report. That comes from interviews, and the output is a portfolio record per application:
| Field | Why it decides something |
|---|---|
| Business owner and criticality tier | Determines acceptable downtime and who approves the cutover |
| Data classification and residency | May rule out regions or force private connectivity |
| Technology stack and OS version | Unsupported versions may force a rebuild rather than a move |
| Licensing model | Per-socket or per-core licences can make cloud hosting uneconomic |
| Integrations, inbound and outbound | Drives wave grouping — coupled systems move together |
| Observed utilisation | Drives target sizing and the cost case |
| Change rate and roadmap | An application being replaced next year should not be refactored |
Dependency mapping is where the real risk hides. Flow data reveals the connections nobody documented: a nightly file drop onto an SMB share, a hard-coded IP address in a batch job, a reporting tool holding an open connection to a production replica. Build the map from observed traffic over at least a full month so that quarterly and end-of-month jobs appear, then cluster applications into move groups — sets that must move together because splitting them would put a chatty, latency-sensitive conversation across a network link.
The seven Rs
Once you know what an application is, you assign it a strategy. The list started as five and is now conventionally seven.
Retire. Switch it off. In most estates ten to twenty per cent of applications have no users, or duplicate something else. Every retirement removes migration cost, licence cost and attack surface. This is the highest-return option and the hardest to get authorised, because someone must accept the risk of being wrong.
Retain. Leave it where it is, for now. Justified by a mainframe dependency, an imminent replacement, a regulator who has not yet approved the target region, or hardware that is not yet depreciated. Retain must carry a review date, otherwise it becomes a permanent data centre with three servers in it and a full support contract.
Rehost. Move the workload as it is — the "lift and shift". Block-level replication tools copy running servers into cloud virtual machines with minutes of downtime at cutover. Fast, low-risk, and requires no application change; it also carries over every inefficiency, so a rehosted estate typically costs more per unit of work than the hardware it left until it is optimised.
Replatform. Move it with targeted changes that buy disproportionate benefit — the "lift and reshape". Typical moves: point the application at a managed database instead of a self-run one, put it behind a managed load balancer with managed certificates, containerise it without redesigning it, or swap a file share for object storage. The application logic is untouched; the operational burden drops sharply. For most estates this is the best default when rehosting is not required by a deadline.
Repurchase. Replace it with a commercial product, usually SaaS. Common for CRM, HR, ticketing, collaboration and mail. The migration work becomes data migration, integration and change management rather than infrastructure, and the total cost is usually dominated by the second and third of those.
Refactor. Rewrite significant parts to use cloud-native services and, often, to change the architecture — decomposing a monolith, moving to event-driven processing, going serverless. It delivers the largest long-term benefit and consumes the largest budget and the most senior people. Reserve it for applications where the business case is specific: a system that cannot scale for a known growth plan, or one whose change lead time is blocking revenue. Refactoring during a data-centre-exit deadline is how programmes miss deadlines.
Relocate. Move a whole virtualisation estate to a cloud-hosted version of the same hypervisor stack, without converting individual machines. Attractive when a large VMware estate must leave a building quickly and conversion effort is unaffordable; it preserves tooling and skills, and it postpones rather than resolves the modernisation question.
Choosing a strategy per application
A workable heuristic, applied per application and then sanity-checked as a portfolio:
Is anyone using it? no -> Retire
Is there a credible SaaS equivalent? yes -> Repurchase
Is it blocked (licence, latency, regulator)? yes -> Retain (with review date)
Is change lead time or scale a real problem
AND is there budget and appetite? yes -> Refactor
Would swapping 1-2 components remove most
of the operational burden? yes -> Replatform
Is the deadline immovable? yes -> Rehost, optimise later
Is the estate large and time short? yes -> Relocate
Two portfolio-level checks matter more than the per-application answer. First, the mix: a plan that is ninety per cent rehost will hit its date and disappoint everyone on cost, while a plan that is thirty per cent refactor will not hit its date at all. Something like sixty per cent rehost and replatform, ten to fifteen per cent retire, a handful of refactors chosen for business impact is a shape that tends to survive contact with reality. Second, sequencing: put the refactors on a separate track with their own funding, so that a slipping rewrite does not block a data-centre exit.
The landing zone comes first
Nothing should move until the destination is ready to receive it safely. A landing zone is the pre-built, automated foundation that every migrated workload lands in. Both major providers publish reference implementations, and building one from a reference is far cheaper than inventing it.
At minimum it provides:
- Account or subscription structure with separate boundaries for production, non-production, shared platform services, security tooling and log archiving.
- Identity integration — federation to the corporate directory, groups mapped to roles, no long-lived credentials, break-glass accounts documented and alarmed.
- Network topology — hub-and-spoke or equivalent, address ranges allocated so they do not collide with on-premises, connectivity back to the data centre via private circuit or VPN, DNS resolution working in both directions.
- Guardrails — policies that prevent resources being created in unapproved regions, require encryption and tagging, and block public storage by default. Preventative controls, not a report published monthly.
- Logging and monitoring — centralised audit logs written to an account nobody else can modify, plus a monitoring stack workloads plug into rather than each inventing one.
- A pipeline and templates so that landing a workload means running automation, not clicking. This is the part of the programme that most repays infrastructure as code discipline.
Hybrid DNS and overlapping IP ranges deserve special mention: they are boring, they are discovered late, and they have delayed more migrations than any application problem.
Moving the data
Data is the part that cannot be redone quickly, so it drives the cutover design.
Bulk transfer. For large static datasets, compute the time honestly: a terabyte over a saturated one-gigabit link takes roughly three hours at theoretical line rate and considerably longer in practice, and estates measured in hundreds of terabytes exceed the window. Physical transfer appliances — ruggedised devices shipped to you, filled and returned — exist for exactly this and are usually faster and cheaper than upgrading a circuit for a one-off.
Continuous replication. For databases, the standard pattern is a replication service that performs a full load and then applies ongoing changes from the transaction log until the source and target are in sync. AWS Database Migration Service and the Azure Database Migration Service both do this, including heterogeneous moves where the engine changes, with a schema conversion step first. Run the replication for days before cutover so the lag is measured, not assumed.
Validation. Row counts are the beginning, not the end. Compare checksums per table, reconcile a business-level total (yesterday's order value, the trial balance), and run the application's own read paths against the target before anyone commits.
The migration approach then falls into one of three shapes:
| Approach | Downtime | Rollback | Use when |
|---|---|---|---|
| Big-bang cutover | Hours | Restore from source, which is still intact | Small or non-critical applications, generous window |
| Trickle / parallel run | Near zero | Keep routing to source | High-value systems, appetite for dual-write complexity |
| Phased by module or tenant | Short per phase | Per-phase | Multi-tenant SaaS, systems that partition cleanly |
Parallel running — both systems live, one authoritative — is the safest and the most expensive, because someone must reconcile the two and decide what happens when they disagree.
Waves, cutover and rollback
Migrations proceed in waves: batches of move groups scheduled together. The first wave is a pilot and its purpose is learning, not throughput. Choose two or three applications that are real, owned, and unimportant enough that a bad weekend is survivable, and instrument the process itself — how long each step took, what the runbook got wrong, which permissions were missing.
Each subsequent wave should have written entry criteria (landing zone ready, owner signed off, dependencies already moved or in the same wave), a runbook with named owners and timings, and explicit exit criteria: error rates and latency within an agreed band, batch jobs completed successfully, reconciliation clean, monitoring alerting correctly.
The rollback plan is what makes the whole thing safe to attempt, and it must be more specific than "we go back". Write down the point of no return — usually the moment writes are accepted on the target and not replicated back — and what the decision looks like on either side of it. Before that point, rollback is repointing DNS or a load balancer at the source. After it, rollback means reverse replication or replaying transactions, which must be tested if you intend to claim it exists.
Immediately after each wave, do two things that programmes routinely skip: decommission the source, because paying for both estates is the standard cost overrun; and right-size the target against a fortnight of real cloud metrics rather than the on-premises estimate, which is where the savings that funded the programme actually come from — see cloud cost management.
Risks worth naming in the plan
Performance regressions from split architectures. During a migration, an application in the cloud is frequently talking to a database still on-premises. A conversation that ran in microseconds now costs milliseconds per round trip, and chatty ORM code degrades non-linearly. Move coupled components in the same wave.
Licence terms that follow the hardware. Some vendors price per physical core or forbid virtualised hosting. Check before the target is designed, not after.
Undocumented integrations firing quarterly. A month of flow data misses the year-end job. Ask finance and operations what happens at period ends.
The unowned tail. Applications with no identifiable owner cannot be retired and cannot be migrated. Escalate them early, with a stated default — usually "we will switch it off on this date unless someone claims it" — because the alternative is discovering the owner in week fifty.
Skills and fatigue. Cutovers happen at weekends. A schedule that assumes the same six engineers can do twelve consecutive weekends is a plan to lose them mid-programme.
Key takeaways
- Discovery, not technology, determines whether a migration succeeds: portfolio records, observed utilisation and a dependency map built from at least a month of traffic.
- The seven Rs — retire, retain, rehost, replatform, repurchase, refactor, relocate — are assigned per application, and the portfolio mix decides whether the programme hits its date.
- Retiring dead applications is the cheapest win available, and rehosting is legitimate provided the optimisation work is scheduled rather than assumed.
- The landing zone — accounts, identity, network, guardrails, logging, pipelines — must exist before the first workload moves.
- Data migration approach follows the acceptable downtime; validate with business-level reconciliation, not row counts.
- Waves need entry and exit criteria, a named point of no return, a rehearsed rollback, and prompt decommissioning of the source to stop paying twice.
Sources and further reading
Frequently asked questions
- Is lift-and-shift a waste of time if we plan to modernise anyway?
- Rarely. Rehosting first gets you out of a data centre whose lease or hardware refresh is driving the deadline, and it decouples the migration risk from the redesign risk. The failure mode is treating rehosting as the end state: the workload now costs more than it did on owned hardware and gains none of the elasticity. Rehost with a dated commitment to optimise, and put that commitment in the same plan.
- How accurate does discovery need to be before we start moving?
- Accurate enough to sequence the first two waves, not perfect. Estates change while you inventory them, so a programme that waits for a complete dependency map never begins. Aim to know every application's owner, criticality, data classification, integration points and licence constraints. The unknown-unknowns are found by moving a small, real, non-critical application early and seeing what breaks.
- Should the migration team or the application team own each move?
- A central migration team owns the factory — the landing zone, the tooling, the runbook templates, the wave schedule — and the application teams own their own cutovers. Fully centralised migrations stall because the central team lacks application knowledge; fully devolved ones produce twenty inconsistent environments. The central team's job is to make the well-paved path so obviously easier that nobody wanders off it.
- What actually causes migration cost overruns?
- Three things dominate. Rehosted virtual machines sized like their on-premises originals, which were bought for a three-year peak. Data egress and inter-region traffic from applications split across the boundary mid-migration. And the long tail: the last fifteen per cent of applications, usually undocumented and unowned, that consume half the programme's remaining budget because nobody will authorise switching them off.