Cloud Migration Strategy and Execution Questions
Planning and executing a move to the cloud: the migration strategies (rehost, replatform, refactor, repurchase, retire, retain), legacy assessment, dependency mapping, cutover planning, and rollback. Covers phased migration roadmaps, workload modernization, risk management during cutover, and validating success post-migration. The end-to-end migration lifecycle, not steady-state operations.
You are responsible for migrating a monolithic, on-premise ERP application that is highly coupled and subject to strict compliance. Present an enterprise migration strategy describing assessment phases, criteria to choose lift-and-shift vs replatform vs refactor vs full rearchitect, incremental decomposition approaches, testing strategy, risk mitigation, timeline estimates, and success milestones.
Sample Answer
Direct answer: For a highly-coupled, compliance-bound monolithic ERP (Enterprise Resource Planning, the class of system that runs an organization's core finance, inventory, and HR processes in one integrated suite), the right approach is a phased strategy: assess and decompose the dependency graph first, pick the migration approach PER MODULE rather than for the whole system, and sequence the compliance-sensitive core last (after the surrounding scaffolding and process are proven on lower-risk pieces).
Structured elaboration
Assessment phase. Before choosing an approach, build a real dependency map: which modules share a database schema, which have synchronous calls to external systems (payment processors, tax engines, EDI partners), and which reports/queries reach directly into tables that other modules also write. For an ERP this typically surfaces 3-5 tightly-coupled clusters (finance/GL -- GL meaning General Ledger, the master record of every financial transaction -- inventory/fulfillment, HR/payroll, and often a reporting layer that reads across all of them). Compliance scope (SOX -- the Sarbanes-Oxley Act, the US law governing financial-reporting controls and audit trails -- and industry-specific controls) usually concentrates in finance and any module handling regulated data, so that scope determines what "strict compliance" constrains: audit-trail continuity through the migration, segregation-of-duties controls staying enforced during any dual-running period, and evidence that the migrated environment reproduces the same control set, not just the same functionality.
Choosing lift-and-shift vs replatform vs refactor vs full rearchitect, per cluster. The reporting layer and any peripheral modules with few external compliance obligations are strong Replatform or even Rehost candidates: get them onto managed infrastructure fast, low risk, buys engineering time. The finance/GL core is the highest-risk piece: a full rearchitect here is rarely justified in the same program (ERP cores are typically 15-20 years of accumulated business logic; rewriting risks silently breaking calculations nobody remembers the rationale for). The pragmatic choice is Rehost or a conservative Replatform (move the database to a managed equivalent, keep the application logic intact) for the core, with refactoring deferred to a LATER, separate initiative once the team has operational confidence in the new environment.
Decomposition approach. Rather than a big-bang cutover of the whole ERP, decompose by BOUNDED CONTEXT (a self-contained business area, like fulfillment or finance, whose data and logic can be grouped and moved as one unit) rather than by technical layer: migrate a full vertical slice (e.g., the entire fulfillment path, database through UI) together, keeping it able to talk back to the still-on-prem finance core through a defined integration seam (typically an anti-corruption layer or API facade) during the transition. This lets you validate the migration approach on a lower-risk cluster before touching the compliance-critical core.
Testing strategy. Beyond functional tests, an ERP migration needs PARALLEL-RUN validation for the compliance-sensitive modules: run old and new systems against the same input stream for a defined period (often a full close cycle for finance, so at least one month-end and ideally one quarter-end), and reconcile every output (ledger balances, tax calculations, reports) rather than sampling, because compliance auditors will ask for exactly this evidence.
Risk mitigation. Key risks: (1) hidden dependencies the discovery phase missed (mitigate with a coexistence period and thorough logging of any call that unexpectedly still targets the old system); (2) compliance-control gaps in the new environment (mitigate by mapping every control to its new-environment equivalent BEFORE cutover, not after); (3) a stalled dual-running period becoming a permanent state (mitigate with a hard decommission date and executive sign-off gating any extension).
Worked example. A realistic 18-month timeline: months 1-3 discovery and dependency mapping; months 4-8 migrate and stabilize the low-risk peripheral modules (reporting, non-regulated inventory); months 9-14 migrate fulfillment/logistics behind an integration seam to the still-on-prem finance core; months 15-17 migrate the finance/GL core itself with a full parallel-run across at least one quarter-end close; month 18 decommission the legacy environment after auditor sign-off. Success milestones are tied to compliance evidence at each stage, not just "module X is live."
Trade-offs & pitfalls. The temptation to refactor the finance core "while we're in there" is the single biggest risk to the timeline and to compliance continuity; a senior architect explicitly defers that work. The second pitfall is sequencing the highest-risk, most-coupled module first because it feels like "getting the hard part out of the way": that inverts the usual play of building operational confidence on lower-stakes migrations before touching the piece where a mistake has real financial-reporting consequences.
You have a portfolio of 200 applications discovered and scored for migration. Describe how you would define migration waves: grouping criteria, size of pilot vs core waves, risk thresholds, rollback windows, acceptance criteria for each wave, and the operational metrics (performance, error rates, cost, runbook readiness) used to decide when to move to the next wave.
Sample Answer
Direct answer: Define waves by combining dependency clustering (applications that must move together stay together) with a risk-graduated sequence: pilot, then progressively larger core waves, with explicit gate criteria between each wave rather than a fixed calendar.
Structured elaboration. Grouping criteria: primary driver is dependency clustering (two apps sharing a database or synchronous API call generally must migrate in the same wave or via a coexistence pattern spanning the gap); secondary driver is similar migration approach (batch apps using the same target-service pattern together, for efficiency of the migration team's tooling and runbooks). Pilot vs core wave sizing: pilot is intentionally small (3-8 low-risk, well-understood applications) purely to validate tooling, runbooks, and rollback mechanics under real conditions; core waves scale up progressively (10, then 20-30 apps per wave) once the pilot proves the process, since early waves are where undiscovered problems in the PROCESS ITSELF (not just individual apps) get found. Risk thresholds: a wave's aggregate risk score (sum or max of its members') gates its size, not just its member count, since one high-risk app effectively caps how many other apps can safely share its cutover window. Rollback windows: each wave gets an explicit rollback decision deadline (e.g., 4 hours post-cutover) beyond which the team commits forward rather than leaving a rollback option open indefinitely, which tends to produce ambiguous half-migrated states. Acceptance criteria: defined per wave before it starts (specific smoke tests, performance thresholds, error-rate ceilings) so "done" isn't a judgment call made under pressure during the cutover window. Operational metrics between waves: performance (latency/error-rate deltas vs. pre-migration baseline), cost (actual vs. estimated), and runbook readiness (did the runbook match what actually happened, or did the team improvise?) all feed into whether the NEXT wave proceeds as planned or gets adjusted.
Worked example. For 200 scored applications: pilot wave of 5 apps (lowest risk, no shared dependencies with anything outside the pilot); wave 2 of 15 apps once pilot's acceptance criteria and rollback windows are validated; waves 3-6 of 30-40 apps each, grouped by dependency cluster and roughly similar risk profile; a final wave of the highest-risk/highest-dependency-count applications, executed last when the team has the most process maturity.
Trade-offs & pitfalls. Grouping purely by "similar technology stack" without checking dependencies is a common mistake: two apps on the same stack but with a synchronous cross-call still need to move together or need an explicit coexistence seam, regardless of how similar their migration mechanics are.
You have to migrate a critical stateful service across cloud providers within nine months for regulatory reasons, but your team lacks experience with the destination cloud. Produce a learning and migration roadmap that minimizes risk to availability: required competencies across team members, timelines for validation, rollback strategies, test plans for data integrity, and cost estimation.
Sample Answer
Direct answer: For a regulatory-driven cross-cloud migration where the team lacks destination-cloud experience, the roadmap has to build team competency IN PARALLEL with the technical migration, not sequentially before it, since a nine-month regulatory deadline doesn't leave room to fully staff up first and migrate second.
Structured elaboration. Required competencies across team members: identify the specific destination-cloud skills the migration actually needs (not a generic "learn cloud X" goal): the target cloud's networking model, its managed-database offering's operational quirks, its IAM model, and its migration/data-transfer tooling; assign these as focused learning tracks to specific team members rather than expecting everyone to learn everything. Timelines for validation: build in explicit, early validation checkpoints on the destination cloud (a small, low-stakes pilot workload migrated first) specifically so skill gaps surface EARLY, while there's still runway to address them, rather than discovering a team's unfamiliarity with the destination cloud's operational model during the actual critical-service cutover. Rollback strategies: given both the regulatory deadline and the team's inexperience, the rollback plan needs to be MORE conservative than a typical migration's, since an inexperienced team is more likely to need it; keep the source cloud fully operational and the rollback path simple (not requiring destination-cloud expertise the team may not yet have under pressure) for longer than would be typical. Test plans for data integrity: rely on straightforward, well-understood validation techniques (checksums, row counts, parity queries) rather than destination-cloud-specific tooling the team hasn't yet mastered, since introducing unfamiliar validation tooling adds its own risk during an already skill-constrained migration. Cost estimation: budget explicitly for training/ramp-up time (which has a real cost in delayed velocity, not just direct training expense) and for the likely need of destination-cloud vendor support or a specialized consulting engagement to cover the gap the team can't close in nine months on its own, given the regulatory deadline doesn't allow for a purely organic learning curve.
Worked example. Month 1-2: identify the 3-4 specific skill areas the migration most depends on, assign owners, and engage the destination cloud's professional-services/support team as an accelerant (a common and reasonable choice given the regulatory time pressure). Months 2-4: migrate a small, low-stakes pilot workload, using it explicitly as a learning vehicle, with the vendor support engagement actively involved to transfer knowledge, not just do the work FOR the team. Months 4-8: migrate the critical service using the patterns validated in the pilot, with the team now meaningfully more experienced. Month 9: buffer for final validation and regulatory sign-off, deliberately not the deadline itself, since a hard-deadline-as-the-final-day plan leaves no room for the unexpected issue an inexperienced-but-improving team is more likely to hit.
Trade-offs & pitfalls. Treating the nine-month deadline as the date the migration COMPLETES, rather than building in a buffer before it for exactly the kind of issue a less-experienced team is more likely to encounter, is a common and risky planning mistake under regulatory time pressure; the worked example above deliberately reserves the final month as buffer rather than migration time.
Scenario: You're asked to lead a cross-team migration of a shared datastore to a new provider. List the ownership responsibilities you would accept, the ones you would expect other teams to own, and the communication plan for risk, rollout, and rollback.
Sample Answer
Direct answer: For a cross-team migration of a shared datastore, explicitly define which responsibilities the migration lead OWNS (the technical migration mechanics, cutover execution, rollback decision) versus which the CONSUMING teams must own (validating their own application's compatibility with the new datastore, testing their own integration points), and build the communication plan around that explicit division so no responsibility silently falls through the gap between teams.
Structured elaboration. Ownership the migration lead should accept: the migration mechanics themselves (replication setup, cutover execution, rollback tooling and decision authority), overall timeline coordination across all consuming teams, and the single source of truth for migration status. Ownership the migration lead should expect other teams to hold: each consuming team validating that ITS OWN application code works correctly against the new datastore (connection strings, query compatibility, any behavioral differences), each team's own testing and sign-off before the shared cutover, and each team's own rollback readiness on their side (can their application gracefully handle the datastore being rolled back, if that happens). Communication plan for risk, rollout, and rollback: a single shared timeline/status channel visible to all consuming teams (not separate one-on-one updates that can drift out of sync), explicit go/no-go checkpoints where EACH team confirms their own readiness (rather than the migration lead assuming readiness on their behalf), and a single, unambiguous rollback decision process (who decides, how it's communicated to all teams simultaneously) since a shared datastore's rollback affects every consuming team at once, unlike a single-team migration where only one team needs to be informed.
Worked example. Ahead of the shared datastore's cutover: each of the 4 consuming teams is given a validation checklist specific to their application (test against a staging copy of the new datastore, confirm query performance and correctness, sign off explicitly), and the cutover only proceeds once all 4 teams have signed off, not just the migration lead's own technical validation. During cutover, a single shared status channel posts updates at each major step (readiness confirmed, cutover starting, cutover complete and validating, either "validated, staying on new datastore" or "rolling back"), so no team is left wondering about status or gets a delayed, inconsistent update. If rollback is triggered, the same channel notifies all 4 teams simultaneously with the same information, and each team's own on-call is responsible for confirming their application recovered cleanly against the reverted datastore, reporting back to the shared channel.
Trade-offs & pitfalls. The most common failure mode in a cross-team shared-resource migration is an IMPLICIT assumption about who owns a specific piece of validation, discovered only when something breaks and each team assumed the other was checking it; writing the explicit ownership division down and getting each team to actively confirm their piece (not just receive a status update) closes that gap before it becomes a production issue.
You discover a tightly coupled dependency between two applications late in the migration program. One team wants to refactor, the other prefers rehosting to keep the timeline. How do you facilitate a technical decision and move forward without jeopardizing the migration schedule?
Sample Answer
Direct answer: When two teams disagree late in a migration program about refactor versus rehost for a newly-discovered tightly-coupled dependency, facilitate a fast, criteria-driven decision (not a consensus-building process that itself burns the timeline) by getting both teams to agree on the DECISION CRITERIA first, then applying those criteria to the specific situation together.
Structured elaboration. Facilitate a technical decision without jeopardizing the schedule: convene both teams quickly (not a delayed, heavily-scheduled meeting, since the disagreement itself is already consuming time and morale) and reframe the conversation from "which option do you each prefer" to "what criteria should decide this," since teams often disagree on the conclusion while actually agreeing on most of the underlying facts; surfacing agreed criteria (time-to-migrate, risk to the schedule, long-term maintainability, actual effort required for refactor GIVEN how late this was discovered) often resolves the disagreement faster than debating the conclusion directly. Weighing the specific situation: given this dependency was discovered LATE in the program, the schedule-risk weight should be explicitly elevated in this specific decision even if refactor might be the objectively "better" long-term answer in the abstract; a late discovery changes the calculus, and both teams should be brought to see that explicitly rather than the facilitator unilaterally deciding it. Moving forward without jeopardizing the schedule: if the criteria-driven analysis still doesn't produce a clear answer within a short, bounded discussion (e.g., one focused meeting, not an open-ended series), the facilitator (as the person accountable for the overall migration timeline) should make the call directly, framed honestly as "we don't have time for full consensus, here's the decision and here's why," rather than letting the disagreement continue to stall the schedule indefinitely while searching for full agreement.
Worked example. Team A wants to refactor the dependency properly (cleaner long-term architecture); Team B wants to rehost to protect the migration deadline. Facilitation: convene both teams, establish shared criteria (schedule impact, risk of the rehost creating future technical debt, actual refactor effort now that it's understood in detail post-discovery), and walk through the criteria together: refactor effort is now estimated at 3 weeks (discovered late, so this directly threatens the deadline), rehost is estimated at 3 days with a documented follow-up ticket to refactor properly in a LATER, dedicated effort once the deadline pressure is gone. Given the schedule criterion is weighted highly for this specific decision, both teams agree (or, if not full agreement, both teams understand the reasoning) that rehost now, refactor later as tracked technical debt, is the right call for THIS moment, distinct from what would be right in a vacuum.
Trade-offs & pitfalls. Letting a genuine architecture-quality disagreement between teams turn into an extended debate without a firm decision deadline is the way this specific situation most commonly damages the schedule; the facilitator's real job here is less about being right on the technical merits and more about ensuring a timely, well-reasoned decision gets made and both teams understand WHY, even if one team doesn't fully agree with the outcome.
Unlock Full Question Bank
Get access to all 9 Cloud Migration Strategy and Execution interview questions and detailed answers.
Sign in to ContinueJoin thousands of developers preparing for their dream job.