Cloud migration strategy: 6R decisions, cutover, rollback and validation

Cloud migration is the planned movement of workloads, data and operational responsibility between environments. That can mean on-premises to AWS, Google Cloud or Azure, movement between providers, a move to European cloud or bare metal, or a cloud exit back to infrastructure the team controls. A successful migration is not just a copy operation: the target must improve something measurable, and the old path must remain available until the new one is proven.

This guide covers workload selection, the 6R model, dependency mapping, price-performance testing, data validation, staged cutover, rollback and failback.

Start with the reason to move

A migration should solve a defined problem. Common reasons include:

  • Current infrastructure cost exceeds the value it provides.
  • Required performance, scaling or regional coverage is missing.
  • A data center or hosting contract is ending.
  • Operations depend on too much manual work or too few people.
  • A managed service would reduce operational burden.
  • A managed service creates unnecessary cost or constraints.
  • Recovery, security or compliance requirements changed.

Turn the reason into acceptance criteria before choosing a provider. Examples include cost per successful transaction, p95 latency, recovery time, deployment effort, operational hours or required data residency. Without these targets, every target architecture looks attractive in a different way.

Migration is per workload, not per company

An organization rarely needs one destination for every application. Inventory the workloads and their characteristics:

  • Business criticality and user journeys.
  • Runtime, operating system, framework and licensing.
  • Data size, growth, consistency and retention requirements.
  • Traffic pattern and performance sensitivity.
  • Integrations, identity, DNS, certificates and third-party dependencies.
  • Current cost and operational effort.
  • Security, compliance and regional constraints.
  • Recovery and rollback requirements.

A static internal tool may be a simple rehost. A database-heavy order system may need replatforming and careful data synchronization. An unused application may simply be retired. A regulated or latency-sensitive workload may need to stay where it is.

Use the 6R model to choose deliberately

The 6R framework assigns a migration decision to each workload. Some taxonomies add relocate as a seventh option for hypervisor-level movement; the principle is the same: do not force one method on the entire estate.

Strategy What it means When it fits Main risk
Rehost Move the workload largely unchanged, often called lift and shift Stable systems, deadline-driven exits, low dependency on old infrastructure Moving existing waste and compatibility problems
Replatform Make limited changes to use a different platform or managed service Containers, managed databases, autoscaling or runtime adjustments that have clear value Underestimating data, identity and operational differences
Repurchase Replace the application with a SaaS or alternative product Commodity capabilities where differentiation has little value Data migration, feature gaps and new vendor lock-in
Refactor Redesign application architecture for the target environment Core systems that need substantial scalability, resilience or delivery improvement Turning a migration into an unbounded rewrite
Retire Decommission what is unused or no longer needed Duplicate, obsolete or abandoned workloads Removing something with an undocumented consumer
Retain Keep the workload where it is for now Recently invested infrastructure, constraints, poor business case or excessive migration risk Treating retention as a reason never to reassess

Retire and retain are valid outcomes. A migration assessment that concludes every server must move is usually incomplete.

Map dependencies before choosing the target

A dependency map shows what breaks when one component changes. Include more than host-to-host connections:

  • Application-to-application calls and service discovery.
  • Database engines, replication, queues and scheduled jobs.
  • Identity providers, service accounts, secrets and certificates.
  • DNS, load balancers, firewall rules and network routes.
  • File storage, object storage, backup and restore paths.
  • Telemetry, alerting and incident runbooks.
  • CI/CD, artifact registries and deployment identities.
  • External providers and operational owners.

For each dependency, record whether it must move, remain, be replaced or be tested in both environments. This becomes part of the cutover and acceptance plan.

Compare price per real performance

Provider list prices do not describe equivalent capacity. A vCPU, disk or managed database can behave differently across instance families and providers.

Build a candidate comparison from:

  1. Current usage and cost baselines.
  2. Candidate compute, storage and network configurations.
  3. Performance tests using representative workloads.
  4. Managed services retained, replaced or removed.
  5. Data transfer and migration costs.
  6. Operational work added or removed.
  7. Recovery, support and exit costs.

Measure successful throughput, p95 and p99 latency, error rates and resource behavior. Then compare cost per useful unit, not just monthly infrastructure price. Our cloud cost and FinOps guide explains the unit-economics model.

A hyperscaler can be the right answer for one workload and a European provider or bare metal for another. Leaving AWS or Google Cloud is not inherently cheaper, and moving into one is not automatically more expensive.

Design the target operating model, not only the target servers

A target architecture includes who and how the platform is run:

  • Infrastructure as code and environment layout.
  • Identity, network, secrets and deployment boundaries.
  • Database and data lifecycle.
  • Monitoring, logging and alert ownership.
  • Backup, restore and disaster recovery.
  • CI/CD, rollout and rollback.
  • Upgrades, maintenance and documentation.
  • Cost review and future exit options.

Replacing managed databases or observability with self-managed components can reduce provider charges while increasing on-call and maintenance work. That trade-off should be explicit in the business case.

Choose a data migration and consistency strategy

Data movement is often the longest part of a migration. Select the method based on size, change rate, allowable downtime and consistency requirements:

  • Full offline export and restore for workloads that can pause.
  • Initial bulk copy followed by change synchronization.
  • Database replication or log-based change capture.
  • Application-level dual reads or carefully controlled dual writes.
  • Object storage synchronization and checksum validation.

Dual writes need special care: partial failure can leave the two systems disagreeing. Define which system is authoritative at each stage and how conflicts are detected and resolved.

Validation should include more than file counts. Depending on the data, check record counts, checksums, required relationships, recent changes, application-level consistency and representative business queries.

Stage the migration instead of using a big bang

A staged plan gives each workload or group a reversible path:

  1. Build the target foundation with infrastructure as code.
  2. Deploy and synchronize without sending production traffic.
  3. Validate functionality, data, security and performance.
  4. Move a small or lower-risk traffic segment where the architecture allows it.
  5. Observe and compare against the baseline.
  6. Complete the cutover only after acceptance.
  7. Keep the old environment available until sign-off and the agreed stability period.
  8. Decommission deliberately rather than immediately.

Lower-risk workloads can go first, but they should be representative enough to teach the team something. A trivial static site does not prove that the database-heavy order system will work.

Cutover needs an explicit acceptance checklist

Before production traffic moves, define who can approve each check and what failure means. A practical checklist includes:

  • Critical user journeys pass in the target.
  • Data counts, consistency and recent changes are validated.
  • Integrations, identity, DNS, certificates and scheduled jobs work.
  • p95 and p99 latency, throughput and errors meet the baseline or agreed target.
  • Monitoring and alerts reach the responsible team.
  • Backup and restoration have been tested.
  • Security and access boundaries match the intended design.
  • The rollback path has been tested and its decision owner is available.
  • Remaining risks and the stability observation period are recorded.

A successful smoke test is not enough for a business-critical migration. Acceptance should reflect the original reason for moving.

Rollback and failback are different engineering problems

Rollback returns from an unsuccessful migration stage to the prior working state. Failback returns from a failover or recovery environment to the normal one. Both need data and traffic decisions, not just old servers.

For rollback, define:

  • The stage at which the source remains authoritative.
  • How new writes after cutover are handled.
  • DNS or load-balancer changes and their propagation behavior.
  • Whether target-side changes must be synchronized back.
  • How monitoring and deployment automation are restored.
  • The maximum point after which rollback requires a new recovery plan.

The disaster recovery and failover guide covers the importance of testing the return path. A migration that only works in one direction is unfinished.

Migration does not eliminate the need for recovery testing

The target platform may offer new resilience features, but their existence does not prove recovery works. Restore infrastructure and data, test critical user journeys, measure actual recovery time and validate the return to normal operation.

If the migration changes database engines, storage or regions, the old recovery assumptions may no longer apply. Update runbooks and ownership before the old environment is retired.

What the UpCloud example shows

In an UpCloud migration, architecture simplification reduced cost by 60-70% versus the initially proposed architecture. After moving to UpCloud, the remaining monthly bill fell to one-half to one-third.

The important lesson is sequencing: simplify first, evaluate the actual architecture, migrate in stages and compare the result against the baseline. The case is not a claim that UpCloud is always the cheapest provider or that the unrelated Proxmox project was part of the same migration. See the UpCloud migration case study.

A different direction can also be right

One crypto platform moved in stages to a self-managed Kubernetes cluster on Hetzner and later to AWS following AWS best practices. Tuning by our engineers and the client's developers reduced costs by 70-80%.

This illustrates why provider direction should follow the workload and operating constraints. A migration strategy is a sequence of evidence-based decisions, not a permanent preference for cloud, bare metal or a particular vendor.

Common migration mistakes

  • Choosing a provider before inventorying workloads.
  • Migrating everything instead of using retire and retain where appropriate.
  • Measuring instance price without measuring real performance.
  • Forgetting identity, DNS, certificates, scheduled jobs and telemetry.
  • Treating data copy completion as proof of consistency.
  • Removing the old environment before acceptance and stability checks.
  • Assuming rollback will work because the old servers still exist.
  • Replacing managed services without accounting for operational effort.
  • Ignoring the FinOps handoff after migration.
  • Calling projected savings realized before the new bill and workload are measured.

A practical migration runbook template

1. Business case

  • Reason to move and measurable acceptance criteria.
  • Current cost, performance, operational and recovery baselines.

2. Workload inventory and decisions

  • Dependencies, data and constraints per workload.
  • Rehost, replatform, repurchase, refactor, retire or retain decision per workload.

3. Target and operating model

  • Architecture, identity, network, data, telemetry and recovery.
  • Managed-service and operational trade-offs.
  • Price-performance comparison and expected unit economics.

4. Execution stages

  • Foundation, deployment, synchronization and validation steps.
  • Traffic and cutover sequence.
  • Owners, communication and decision points.

5. Acceptance and rollback

  • Functional, data, performance, security and recovery checks.
  • Rollback authority, data authority and tested return path.
  • Stability observation period and decommission approval.

6. After the move

  • Actual cost and performance against the baseline.
  • Right-sizing and remaining remediation.
  • Updated runbooks, documentation and operational ownership.
  • A recurring cost, reliability and recovery review.

Big Bad Byte's cloud migration service follows this model across AWS, Google Cloud, Azure, European providers, bare metal and on-premises: measure first, choose per workload, migrate in stages and verify both performance and the way back.

Tell us about your setup

Describe what you run and what isn’t working: the cloud bill, response times, releases or recurring incidents. We reply within one business day with a suggested first step, usually a short call or an audit.

Prefer email? Write to info@bigbadbyte.com. Prefer to talk? Schedule a call.