This chapter covers the three primary cloud migration strategies: lift-and-shift (rehosting), modernizing (refactoring), and rebuilding (rearchitecting). For the Google Cloud Digital Leader (GCDL) exam, understanding these strategies is critical because they appear in roughly 10-15% of questions across multiple domains, particularly in the 'Apps' domain under objective 4.1. The exam tests your ability to recommend the right strategy based on business needs, technical constraints, and organizational maturity. You must know not just definitions but also when each strategy is appropriate, its trade-offs, and how Google Cloud services support each approach.
Jump to a section
Imagine you own a house that needs to be relocated to a new neighborhood, but you can't move the land itself. You have three options. Option 1: Lift-and-shift. You hire a moving company to physically pick up the entire house, transport it on a flatbed truck, and set it down on a new foundation. Everything inside stays exactly as it was—furniture, wiring, plumbing—but now it sits on a different plot. The house works identically, but you didn't fix any existing issues like drafty windows or old pipes. Option 2: Modernize (refactor). You disassemble the house into major components—roof, walls, floors, systems—and rebuild it with better materials and modern techniques. You keep the same floor plan and purpose, but you upgrade insulation, replace old wiring with code-compliant electrical, and install energy-efficient windows. The result is a better, more maintainable house that still feels like your original home. Option 3: Rebuild (rearchitect). You demolish the old house entirely and build a brand-new house from scratch using the latest architectural designs and materials. You might add a second floor, change the layout, or use smart home technology. This gives the most flexibility and performance but requires the most time, money, and effort. In cloud migration, these three approaches correspond to lift-and-shift (rehosting), modernizing (refactoring), and rebuilding (rearchitecting). Each has different trade-offs in speed, cost, and long-term benefits.
What Are Cloud Migration Strategies?
Cloud migration strategies define how an organization moves its on-premises applications and data to the cloud. The three most common strategies are lift-and-shift (rehost), modernize (refactor/improve-and-move), and rebuild (rearchitect). These strategies exist on a spectrum from minimal change to complete transformation. The choice depends on factors like business urgency, technical debt, budget, and long-term goals.
Lift-and-Shift (Rehosting)
Lift-and-shift involves moving an application from an on-premises environment to the cloud with minimal modifications. The application runs on virtual machines (VMs) in the cloud, often using the same operating system, middleware, and configuration. In Google Cloud, this typically means migrating to Compute Engine instances using tools like Migrate for Virtual Machines (formerly Velostrata) or importing VM images.
How it works: - An administrator exports the on-premises VM as a disk image (e.g., VMDK, VHD). - The image is uploaded to Google Cloud Storage. - A new Compute Engine instance is created using that image. - Networking is configured to match the original environment (IP addresses, firewall rules). - DNS records are updated to point to the new cloud IP.
Key characteristics: - Speed: Fastest migration path—weeks to months. - Cost: Low initial effort, but ongoing costs may be higher because applications are not optimized for cloud. - Risk: Lowest risk of application failure because behavior is identical. - Scalability: Limited—the application is not designed for cloud-native scaling. - Maintenance: You still manage OS patches, middleware, and licensing.
When to use: - Tight deadlines (e.g., data center lease expiration). - Applications that are difficult to change (e.g., legacy COTS software). - As a first step before refactoring later.
Exam tip: The GCDL exam often presents a scenario where a company needs to migrate quickly due to a data center closure. The correct answer is lift-and-shift.
Modernizing (Refactoring/Improve-and-Move)
Modernizing means making moderate changes to an application to take advantage of cloud capabilities without a full rewrite. This often involves moving from monolithic architectures to microservices, using managed services like Cloud SQL instead of self-managed databases, or containerizing applications with Kubernetes.
How it works: - The application is broken into smaller components. - Each component is deployed using appropriate Google Cloud services:
Compute: Google Kubernetes Engine (GKE) for containerized workloads.
Storage: Cloud Storage for objects, Cloud SQL or Spanner for relational data.
Networking: Cloud Load Balancing, Cloud CDN.
The application is re-platformed to use PaaS services where possible (e.g., App Engine, Cloud Run).
Existing code is modified to use cloud APIs (e.g., Cloud Pub/Sub for messaging).
Key characteristics: - Speed: Moderate—months to a year. - Cost: Moderate initial investment, but lower ongoing costs due to managed services and better resource utilization. - Risk: Moderate—some behavior changes may require testing. - Scalability: Improved—can leverage auto-scaling and load balancing. - Maintenance: Reduced—Google manages the underlying platform for PaaS services.
When to use: - Applications with moderate technical debt. - When you want to reduce operational overhead. - When the business can tolerate some downtime during migration.
Exam tip: The exam often tests the concept of 're-platforming'—moving to a managed database like Cloud SQL instead of self-managing MySQL on a VM. This is a form of modernizing.
Rebuilding (Rearchitecting)
Rebuilding involves completely redesigning an application using cloud-native architectures. This is the most transformative strategy, often resulting in a microservices-based application that runs on serverless compute or containers, uses managed databases, and integrates with cloud services for analytics, AI, and more.
How it works: - The application is rebuilt from scratch using cloud-native design patterns. - Frontend: Cloud Run or App Engine for serverless hosting. - Backend: Cloud Functions for event-driven logic, GKE for complex microservices. - Database: Firestore or Bigtable for NoSQL, Cloud Spanner for globally distributed relational data. - Messaging: Cloud Pub/Sub for async communication. - The application is designed for horizontal scaling, fault tolerance, and continuous deployment.
Key characteristics: - Speed: Slowest—months to years. - Cost: Highest initial investment, but lowest long-term operational costs. - Risk: Highest—new code may introduce bugs. - Scalability: Best—cloud-native auto-scaling and global distribution. - Maintenance: Minimal—serverless and managed services eliminate most operational tasks.
When to use: - When the current application is obsolete or has high technical debt. - When you need to add new features that are impossible with the current architecture. - When you want to achieve cloud-native benefits like auto-scaling, pay-per-use, and global reach.
Exam tip: The exam may ask which strategy is best for a startup building a new application. The answer is rebuild (rearchitect) because there is no legacy to maintain.
Google Cloud Tools for Each Strategy
Lift-and-shift: Migrate for Virtual Machines, Compute Engine, Cloud VPN/Interconnect.
Modernizing: GKE, Cloud SQL, Cloud Run, App Engine, Cloud Storage.
Rebuilding: Cloud Functions, Firestore, Bigtable, Spanner, Pub/Sub, Cloud Run, GKE.
Migration Phases (Common to All Strategies)
Assess: Inventory applications, dependencies, and performance baselines.
Plan: Choose strategy for each application based on business and technical factors.
Migrate: Execute the migration using appropriate tools.
Validate: Test functionality, performance, and security.
Optimize: Right-size resources, adjust configurations, and decommission old systems.
Cost Implications
Lift-and-shift: Immediate cost savings from eliminating data center, but cloud costs may be higher if resources are not optimized.
Modernizing: Moderate upfront cost, but long-term savings from managed services and better utilization.
Rebuilding: High upfront cost, but maximum long-term savings and agility.
Security Considerations
Lift-and-shift: Security posture remains the same; you must still manage OS patching and firewall rules.
Modernizing: Improved security through managed services (e.g., Cloud SQL provides automated backups and encryption).
Rebuilding: Best security posture—can leverage IAM, VPC Service Controls, and Cloud Armor.
Performance
Lift-and-shift: Similar to on-premises; no inherent performance improvement.
Modernizing: Better performance due to optimized infrastructure (e.g., SSDs, load balancing).
Rebuilding: Best performance—designed for cloud scalability and global distribution.
Summary Table
| Strategy | Speed | Cost (Initial) | Cost (Ongoing) | Risk | Scalability | Maintenance | |----------|-------|----------------|----------------|------|-------------|-------------| | Lift-and-shift | Fast | Low | High | Low | Limited | High | | Modernizing | Medium | Medium | Medium | Medium | Good | Medium | | Rebuilding | Slow | High | Low | High | Excellent | Low |
Exam-Relevant Numbers
The GCDL exam does not require memorizing specific dollar amounts, but you should know that lift-and-shift typically yields 30-50% cost savings in the first year (by eliminating data center costs) but may increase cloud spend if not optimized.
Modernizing can reduce operational costs by 40-60% over three years.
Rebuilding can reduce total cost of ownership (TCO) by 50-70% over five years.
Common Trap Patterns
Trap: Choosing lift-and-shift for an application that needs new features. Reality: Lift-and-shift does not add new functionality; you would need to modernize or rebuild.
Trap: Choosing rebuild for a legacy application that is stable and running fine. Reality: Rebuild is high-risk and expensive; modernizing or lift-and-shift is more appropriate.
Trap: Thinking lift-and-shift is always the cheapest. Reality: Initial cost is low, but ongoing costs can be higher than modernized applications due to inefficient resource usage.
How Strategies Interact with Other Technologies
Containers: Modernizing often involves containerizing applications using GKE. Containers enable easier scaling and deployment.
Serverless: Rebuilding often uses serverless services like Cloud Functions and Cloud Run, which eliminate infrastructure management.
Managed Databases: Modernizing and rebuilding both leverage managed databases (Cloud SQL, Spanner) to reduce operational overhead.
CI/CD: All strategies benefit from CI/CD pipelines, but rebuilding typically integrates the most advanced DevOps practices.
Configuration and Verification
While the GCDL exam does not require command-line proficiency, understanding the tools helps:
Migrate for Virtual Machines: Use the gcloud command to create a migration plan.
GKE: Deploy a containerized app using kubectl apply -f deployment.yaml.
Cloud Run: Deploy with gcloud run deploy --image gcr.io/project/image.
Conclusion
Choosing the right migration strategy is a balance of speed, cost, risk, and long-term goals. The GCDL exam will test your ability to recommend the appropriate strategy based on a given scenario. Always consider the business context: if speed is critical, choose lift-and-shift; if you want to reduce operational overhead, choose modernizing; if you need to innovate, choose rebuilding.
Assess current on-premises environment
Begin by inventorying all applications, including dependencies, performance baselines, and resource utilization. For each application, identify the operating system, middleware, database, and networking requirements. Use tools like Google Cloud's Migration Readiness Assessment or third-party tools to evaluate compatibility. This step determines which migration strategy is feasible. For example, if an application relies on a specific version of a database that is not available as a managed service, lift-and-shift may be the only option. Document all inter-application dependencies (e.g., API calls, shared databases) to plan the migration order.
Choose migration strategy per application
Based on the assessment, assign a strategy to each application. Business factors drive the decision: urgency, budget, and desired outcomes. For instance, a critical legacy ERP system that cannot be modified may be assigned lift-and-shift. A web application with moderate technical debt may be modernized by containerizing it with GKE. A mobile app backend that needs global scaling may be rebuilt using Cloud Run and Firestore. Document the rationale for each decision, as the exam may ask you to justify a strategy choice.
Execute migration using appropriate tools
For lift-and-shift, use Migrate for Virtual Machines to replicate VMs to Compute Engine. For modernizing, refactor code to use managed services like Cloud SQL and deploy containers on GKE. For rebuilding, develop new code using cloud-native services like Cloud Functions and deploy via CI/CD pipelines. Ensure network connectivity between on-premises and cloud (via Cloud VPN or Interconnect) during the migration period. Test each migrated component in isolation before cutting over.
Validate functionality and performance
After migration, run smoke tests to verify that the application behaves as expected. Compare performance metrics (latency, throughput) against baselines collected in the assess step. Check that all integrations (e.g., third-party APIs, authentication) work correctly. For lift-and-shift, validation is straightforward because behavior should be identical. For modernized or rebuilt applications, more extensive testing is needed because the architecture has changed. Use Google Cloud's Operations Suite (formerly Stackdriver) for monitoring and logging.
Optimize resources and decommission legacy
After successful validation, optimize cloud resources: right-size VM types, enable auto-scaling, and shut down idle instances. For modernized applications, adjust database tier and storage class. For rebuilt applications, fine-tune serverless configurations (e.g., Cloud Run concurrency, memory limits). Finally, decommission on-premises hardware and update DNS records to point exclusively to cloud endpoints. This step reduces costs and eliminates the need to maintain dual environments.
Enterprise Scenario 1: Data Center Lease Expiry
A large retail company has a 10-year lease on a data center that expires in 9 months. They have 500 applications running on legacy hardware, including a 20-year-old inventory management system written in COBOL. The IT team cannot modify the COBOL application because the original developers have retired. The company decides to lift-and-shift the COBOL system to Compute Engine using Migrate for Virtual Machines. They also modernize 300 web applications by moving them to GKE and Cloud SQL. The remaining 199 applications are rebuilt as microservices on Cloud Run over the next two years. The lift-and-shift migration takes 6 months, allowing them to vacate the data center on time. The modernized applications reduce operational costs by 45%, and the rebuilt applications enable new features like real-time inventory tracking.
Enterprise Scenario 2: Healthcare Provider Modernization
A healthcare provider wants to improve patient portal performance and reduce compliance burden. Their current application runs on-premises with a monolithic Java architecture and Oracle database. The compliance team requires encryption at rest and in transit, as well as automated backups. The provider chooses to modernize by moving the database to Cloud SQL (which provides automatic encryption and backups) and containerizing the Java application on GKE. They keep the same codebase but modify configuration to use Cloud SQL's JDBC driver. The migration takes 4 months, and the new environment reduces database administration time by 70%. The application now auto-scales during peak hours, improving patient experience.
Common Pitfalls
Underestimating network latency: After lift-and-shift, an application that depended on low-latency on-premises connections to other services may experience higher latency in the cloud. This can cause timeouts. Always test network performance.
Ignoring licensing: Some software licenses (e.g., Oracle, Microsoft) have specific terms for cloud deployment. Lift-and-shift may violate license agreements if not properly addressed. Use Google Cloud's license mobility options or consider modernizing to open-source alternatives.
Not optimizing after migration: Many teams forget to right-size resources after lift-and-shift, leading to overprovisioned VMs and higher costs. Use Google Cloud's recommender tools to identify idle resources.
What the GCDL Exam Tests
The GCDL exam tests your ability to recommend a migration strategy based on a business scenario. Key objective codes: Domain 'Apps', Objective 4.1: 'Identify the appropriate migration strategy for a given application or workload.' The exam expects you to understand the trade-offs between lift-and-shift, modernize, and rebuild. You will not be asked to execute commands, but you must know which Google Cloud tools support each strategy.
Common Wrong Answers and Why
Choosing lift-and-shift for an application that needs new features: Candidates often think lift-and-shift is the easiest path, but it does not add functionality. The correct answer is modernize or rebuild.
Choosing rebuild for a legacy application with no issues: Candidates may overestimate the need for transformation. If the application works fine and the business is not demanding new features, lift-and-shift or modernize is more cost-effective.
Thinking modernizing is always faster than lift-and-shift: This is false. Lift-and-shift is the fastest. Modernizing requires code changes and testing.
Assuming lift-and-shift is always the cheapest: Initial cost is low, but long-term costs can be higher due to inefficient resource usage. The exam may present a scenario where a company wants to reduce long-term costs, and the answer is modernize or rebuild.
Specific Numbers and Terms
The exam uses the terms 'rehost' (lift-and-shift), 'refactor' (modernize), and 'rearchitect' (rebuild).
Know that 'replatform' is a subset of modernize where you move to a managed service (e.g., from self-managed MySQL to Cloud SQL).
The exam may mention 'Migrate for Virtual Machines' as the tool for lift-and-shift.
'GKE' and 'Cloud Run' are associated with modernizing and rebuilding.
Edge Cases
Hybrid strategy: Some applications may use a combination of strategies. For example, a database may be lifted to Cloud SQL while the application is rebuilt. The exam may present this as 'move the database to Cloud SQL and rewrite the application'—that is a combination of modernize (database) and rebuild (app).
Retire: Occasionally, the best strategy is to retire an application if it is no longer needed. The exam may include this as a fourth option.
How to Eliminate Wrong Answers
If the scenario emphasizes speed (e.g., 'must migrate within 3 months'), eliminate rebuild and modernize if they take longer.
If the scenario emphasizes cost reduction over time, eliminate lift-and-shift because it has higher long-term costs.
If the scenario mentions 'no code changes', eliminate modernize and rebuild; only lift-and-shift fits.
If the scenario mentions 'need to add new features', eliminate lift-and-shift; choose modernize or rebuild.
Lift-and-shift (rehost) moves applications to the cloud with no changes; fastest but least optimized.
Modernize (refactor) makes moderate changes to use managed services; balances speed and optimization.
Rebuild (rearchitect) rewrites applications as cloud-native; slowest but most scalable and cost-effective long-term.
The GCDL exam tests your ability to choose the right strategy based on business drivers: speed, cost, risk, and features.
Google Cloud tools: Migrate for Virtual Machines (lift-and-shift), GKE and Cloud SQL (modernize), Cloud Run and Cloud Functions (rebuild).
Common trap: thinking lift-and-shift is always cheapest; long-term costs may be higher.
Always consider a portfolio approach—different applications may use different strategies.
The terms 'rehost', 'refactor', and 'rearchitect' are used interchangeably with lift-and-shift, modernize, and rebuild on the exam.
These come up on the exam all the time. Here's how to tell them apart.
Lift-and-Shift (Rehost)
Fastest migration; minimal changes to application.
Low initial cost; no development effort required.
High ongoing operational overhead (OS patches, middleware).
Limited scalability; no cloud-native features.
Best for legacy applications with tight deadlines.
Modernize (Refactor)
Moderate migration time; some code changes needed.
Moderate initial cost; development effort required.
Lower operational overhead due to managed services.
Improved scalability via containers or auto-scaling.
Best for applications that need reduced maintenance.
Modernize (Refactor)
Incremental changes; existing codebase partially reused.
Medium risk; behavior changes are limited.
Uses managed services like Cloud SQL and GKE.
Moderate long-term cost savings (40-60%).
Suitable for applications with moderate technical debt.
Rebuild (Rearchitect)
Complete rewrite; no legacy code remains.
High risk; new code may introduce bugs.
Uses serverless and cloud-native services like Cloud Run and Firestore.
Maximum long-term cost savings (50-70%).
Best for applications needing new features or global scale.
Mistake
Lift-and-shift always saves money compared to on-premises.
Correct
Lift-and-shift can save money by eliminating data center costs, but if the application is not optimized for cloud, it may cost more due to overprovisioned resources and lack of auto-scaling. Many organizations see 30-50% savings initially, but ongoing costs can be higher if not managed.
Mistake
Modernizing requires rewriting the entire application.
Correct
Modernizing often involves incremental changes, such as moving a database to a managed service or containerizing the application. The core code may remain largely unchanged. Only rebuilding involves a full rewrite.
Mistake
Rebuilding is always the best long-term strategy.
Correct
Rebuilding is expensive and risky. If the current application meets business needs and has low technical debt, lift-and-shift or modernize may be more cost-effective. Rebuilding is best when the application needs new capabilities or the architecture is obsolete.
Mistake
Lift-and-shift is not a valid cloud strategy.
Correct
Lift-and-shift is a valid and common strategy, especially for legacy applications that cannot be modified. Many organizations use it as a first step to get to the cloud quickly, then modernize later.
Mistake
All applications should be migrated using the same strategy.
Correct
Different applications have different needs. A portfolio approach is best: some applications are lifted, some modernized, some rebuilt, and some retired. The exam often tests this nuanced view.
Reveal each answer, then mark whether you got it right. Score 60%+ to unlock the next chapter.
They are the same thing. 'Rehost' is the official term used in cloud migration frameworks, and 'lift-and-shift' is the colloquial term. Both mean moving an application to the cloud with minimal changes. The GCDL exam uses both terms interchangeably.
Choose modernize when you have time (a few months) and want to reduce operational overhead. For example, if you are currently managing your own database and want to use Cloud SQL instead, that's modernizing. If you need to move quickly (e.g., data center closing in 3 months), lift-and-shift is better.
Yes, for new applications that are built from scratch, rebuilding (using cloud-native services) is the best approach because you have no legacy constraints. You can design for scalability, resilience, and cost efficiency from the start.
The primary tool is Migrate for Virtual Machines (formerly Velostrata). It allows you to migrate on-premises VMs to Compute Engine with minimal downtime. You can also use VM import/export features.
Yes, it's common. For example, you might lift-and-shift the application tier but modernize the database by moving to Cloud SQL. This hybrid approach is called 'replatform' in some frameworks. The exam may test this nuance.
Rebuilding (rearchitecting) is the riskiest because it involves rewriting the entire application from scratch. New code may contain bugs, and the application may not perform as expected. Thorough testing is critical.
The exam presents a scenario (e.g., 'Company X needs to migrate 200 apps within 6 months; they have a legacy CRM that cannot be modified. Which strategy is best?') and you must choose the appropriate strategy. Focus on the business constraints given in the question.
You've just covered Migration Strategies: Lift-and-Shift, Modernize, Rebuild — now see how well it sticks with free GCDL practice questions. Full explanations included, no account needed.
Done with this chapter?