Cloud Migration Challenges and How to Reduce Risk
Explore the main cloud migration challenges, from cost overruns and hidden dependencies to security limits and exit risk, with checks to run first.
McKinsey's 2021 study of cloud migration found that the inefficiencies it measured could produce about $100 billion in wasted migration spending over three years (McKinsey cloud migration research). That figure isn't the cost of failed projects. It's the cost of ordinary ones: sensible architecture, competent teams, and a plan that priced the move but not the transition.
The forgotten work follows a pattern. Nobody owns the cost of running two environments at once. The knowledge embedded in the platform leaves with the people who built it. The organisation discovers how hard it is to leave its provider only after it wants to. Those three risks rarely make it onto a steering deck, and each one is a decision that can be settled before the first workload moves rather than after.
Turning the reported cloud migration challenges into a register with a named owner, an early warning sign and a first control is the most useful risk reduction available at the start of a programme. Everything after that is execution.
The Challenges Teams Report Most and How to Spot Them
A risk register is useful only when it shows what would make a risk visible and who must act. The table pairs reported migration challenges with an early warning sign and a first control. Use it to test whether a plan has an owner and evidence for each risk.
| Challenge | How often it is reported | Early warning sign | First control |
|---|---|---|---|
| Cost and schedule overruns | Average 14% over planned spend; 38% saw delays over one quarter (McKinsey's cloud migration research) | Budget lines with no contingency or dependency time | Staged milestones with contingency funding and exit criteria |
| Application dependencies | 54% named understanding them a challenge (published survey reporting on migration cost) | Integrations first tested at cutover | Dependency map validated against production telemetry |
| Technical feasibility | 44% cited assessing technical feasibility (published survey reporting on migration cost) | Workloads that fail performance tests late | Per-workload feasibility test before wave planning |
| Cost comparison | 43% cited comparing on-premises and cloud costs (published survey reporting on migration cost) | Cloud bills differ from the forecast | Full lifecycle cost model for each workload |
| Security and compliance | Nearly half rated it a major difficulty (published survey reporting on migration cost) | Data location questions raised after design | Control ownership and evidence agreed before moving |
| Resistance to change | A reported challenge, with no share stated | Teams keep old workarounds running | Named owners and a dated switch-off plan |
| Planning gaps | A reported challenge, with no share stated | Milestones move without a stated reason | Measurable exit criteria for each phase |
McKinsey's 2021 study of about 450 chief information officers and other IT decision-makers found the average company spent 14% more on migration than originally planned each year, and 38% had experienced delays of more than one quarter (McKinsey's cloud migration research). The 2023 survey reporting found that 54% named understanding application dependencies, 44% cited technical feasibility, 43% cited comparing on-premises and cloud costs, and nearly half rated security and compliance a major difficulty (published survey reporting on migration cost). These are survey findings, not forecasts for an individual programme.
Overruns arrive through a contract, not a cloud bill
McKinsey identified systems-integrator spending as the most frequently cited source of cost overruns outside change management. That points to a practical failure mode: when an unmapped integration appears late in a migration wave, teams may need to extend delivery and add people to resolve it. The programme owner should track scope changes and the cost of external delivery alongside infrastructure spend.
Schedule and cost risks reinforce each other. A delayed wave can keep the old environment, licences and support obligations in place while engineers spend time maintaining it instead of delivering the next workload. Assign one owner to track the combined transition cost, including the period when both environments must run.
Score the plan, then pick a first wave
For every row, ask who owns the risk by name and what evidence would show it is controlled.
- No owner, no evidence. The risk is unmanaged, whatever the status report says.
- Owner but no evidence. Assign a specific artefact, such as a telemetry-validated dependency map, a workload cost model or a signed control statement.
- Evidence but no expiry. Controls can drift as designs change. Set a review point and require renewed approval when the underlying design changes.
Use the scores to choose a first wave whose owners, evidence and exit criteria are clear. For a wider catalogue of common challenges and mitigations, overcoming obstacles when moving to cloud collects patterns to compare against a migration plan already underway.
Why Hidden Dependencies Break a Cutover
A server inventory tells you what's running. It doesn't tell you what feeds it.
Think about moving house and disconnecting the kitchen without checking which pipes feed the sink. The van arrives, everything looks tidy, and the problem appears the moment someone turns on the tap. Applications behave the same way. A service that looks self-contained usually depends on a database, an identity provider, a scheduled job, a file drop, a network allow-list or a third-party feed that nobody wrote down.
The sequence below is the one that catches most of these before cutover.

The break appears at the worst moment
Dependency gaps don't announce themselves during discovery. Legacy estates hide undocumented database relationships, synchronous service calls, tightly coupled components and assumptions about low-latency internal networks, and those surface during cutover as broken integrations, inconsistent data or unexpected downtime (Flexera's State of the Cloud research).
Five controls in the order that works
- Trace the connections first. An inventory lists servers; the risk lives in relationships. Trace every database connection, API call, queue, scheduled job, identity flow and network path, including the ones that leave your estate entirely.
- Check that map against production telemetry. Documentation records what someone intended. Telemetry records system behavior, including the 02:00 batch job and the retry loop that keeps a partner feed alive. Where the two disagree, the telemetry is right.
- Give each dependency an owner, a required order and a rollback condition. A dependency without an owner becomes an incident. Without an order it becomes a failed wave. Without a rollback condition it becomes an outage you can't reverse.
- Group workloads into dependency-aware waves. Move the things other systems depend on once their own foundations are stable, and never schedule two waves that share a data store in the same window.
- Reconcile before the next wave starts. Row counts, checksums, referential integrity and a sample of real reports. If the numbers don't match, the wave isn't finished, whatever the deployment pipeline says.
The US Department of Defense migration guidance asks teams to assess interdependencies among applications so migration phases can be planned effectively, and to preserve data integrity, security and privacy during transfer (DoD Cloud Migration Primer). Flexera's research names understanding application dependencies and assessing technical feasibility as the two leading migration challenges across organisation sizes.
What the gap looks like on a real platform
Say a reporting application reads from a database that stays on premises, and it moves first because it looks small and low-risk. The nightly job that writes the summary fails in week one. Nobody tested it because the application's own tests passed, and the database belonged to somebody else's system.
That's why mapping has to go past infrastructure. When Grail Computer Labs took on an inherited healthcare platform, it modelled the core journey as a state model with 27 states and 39 transitions, which exposed missing paths for cancellations, disputes, failed fulfilment, notifications and admin recovery. Those paths are dependencies in everything but name.
The same discipline applies at integration level. Start from the system of record, define the exact fields and actions each component is allowed to use, and make ownership explicit, or the integration turns brittle the first time a field changes. For teams planning a staged move off fragile systems, the legacy system migration approach worth copying establishes an observable baseline first, then introduces parallel synchronisation and reversible cutovers.
The question to answer for every workload is the same. If this one application moves alone, what fails, and who finds out first?
Security and Compliance Limits on Where Workloads Run
By the time security review starts, the region, key hierarchy, log destination and network design may already be fixed. Changing them can mean redesigning the workload, delaying the move or accepting a control gap.
A 2025 cloud-security survey found that 61% of respondents cite security and compliance as a major cloud-adoption challenge, while 48% cite technical challenges, particularly in complex hybrid environments (2025 Cloud Security Report). Both figures point to one problem from different seats: security requirements often depend on technical choices made during migration.
Compliance can determine whether a workload is allowed to run in a particular location at all.

Six decisions to make before a workload moves
- Classify the data and record where it may sit. Document sensitivity, retention period and permitted jurisdictions for each workload.
- Map the jurisdictions that apply. A single application may involve several jurisdictions through its users, backups and the support staff who can access its logs.
- Enforce least privilege for people and services. Service identities are easy to overlook and may retain more access than necessary.
- Encrypt data in transit and at rest, and name the key owner. A platform may manage the encryption mechanism, but an accountable person still needs to own key rotation and exceptions.
- Send immutable audit logs to the target environment. Logs that can be edited cannot provide a reliable audit trail.
- Test recovery against the required recovery-time and recovery-point objectives. Without a timed restore, recovery capability remains an assumption.
Build these controls into infrastructure and deployment pipelines so they apply consistently to each release. Document exceptions, assign an owner and set an expiry date.
The failure to design out: A patient-records service runs in the target region and passes functional tests, but its backups cannot legally be stored in that jurisdiction. The conflict surfaces when an auditor requests evidence.
For multi-tenant platforms, classification also has to account for different customers' retention rules. Each organisation needs clear boundaries for credentials, stored data, retention rules and usage records. Those boundaries should be defined before migration, not added after workloads have moved.
For each workload, decide where its data may legally sit, who approves changes to that decision and what evidence the team can provide after cutover.
Paying for Two Environments During the Move
The overlap is where the money goes, and it usually has no owner. A migration is a temporary operating model, but teams often budget the destination more carefully than the months when both environments are running.
Managing cloud spend is the leading challenge for 84% of organisations, and 75% also cite governance, software-licence management and limited expertise as major issues (Flexera State of the Cloud 2025). Those pressures are especially visible during migration, when duplicate services and contracts can persist beyond the planned cutover.
The ledger is what matters here: one record that adds up both environments, duplicated licences, transfer charges, support contracts that remain active and capacity held for rollback. Assign an owner before the first workload moves.

The cost lines that appear while both environments run
| Cost line | When it starts | How to measure it | Owner |
|---|---|---|---|
| Dual-running infrastructure | First parallel run | Monthly bill for old and new environments | Migration owner |
| Duplicated software licences | When licences overlap | Licence count per environment | Procurement lead |
| Data-transfer charges | First data sync | Transfer volume by route | Platform owner |
| Support contracts | Until the old environment is retired | Contract value still running after cutover | Finance lead |
| Rollback capacity | From cutover until the sunset test passes | Reserved capacity kept on standby | Platform owner |
Each line has a clear trigger and measure. The gap is ownership: architecture milestones rarely show who tracks a support contract that should have ended or capacity still reserved after a successful cutover.
Four controls that keep the ledger honest
Unit economics per workload. Track cost per transaction, tenant or thousand jobs in both environments. A total spend figure can hide which workloads are driving the increase.
A sunset test for the old environment. Write down the checks, deadline and person authorised to declare the old system retired. Without a defined exit, temporary dual-running can become permanent.
Approval thresholds for unexpected spend. Set in advance who can approve an overrun of 10%, 25% or 50%. That gives the team a decision path if a migration wave fails or takes longer than planned.
A named owner for post-migration optimisation. Assign accountability for the target environment six months after go-live, when the migration team may have moved on. That owner can continue rightsizing and scheduling to cut spend as workloads settle.
Moving workloads to the cloud can raise costs when governance and workload-level accountability arrive after the move. The trade-off is straightforward: paying for both environments temporarily can protect a cutover, but each extra week needs a business reason and a retirement condition.
Before the first wave, name the cost owner and give them access to both bills. Agree the sunset test with the business, and have the budget holder approve the spend thresholds. These controls make the overlap visible while there is still time to change course.
Keeping Undocumented Know-How Through the Handover
A migration can have an approved plan and still lack the knowledge needed to execute it safely. Foundry's 2025 cloud research found that 53% of IT leaders reported data-portability challenges during migration and 52% reported complexity in modernising legacy systems (Foundry's 2025 cloud research). Both problems can arise when system behaviour and decision history are not recorded where the receiving team can use them.
The perception gap matters too. A 2025 survey found 23% of vice-presidents and directors reported lacking the right partner expertise, compared with 6% of C-level leaders. Executive approval can coexist with delivery teams' concerns about whether the work can be completed.
The questions nobody writes down
When the incumbent supplier leaves, who can explain why a scheduled job runs at 03:15 rather than 02:00, or which rule prevents a duplicate payment after a retry? Where is the decision history kept: in a wiki, a ticket, or an engineer's memory? How will the replacement team prove the rebuilt platform behaves like the old one before cutover?
These answers are often distributed across tickets, meeting notes, code and the people who made the decisions. When those people move to other work, undocumented behaviour becomes a handover risk.

What an evidence-backed handover record contains
A useful handover record connects system behaviour to evidence the next team can check:
- Dependency maps name each link, its owner and how it can fail.
- Decision logs record what was tried, what was rejected and why, reducing the chance that the next team repeats the same investigation.
- Testable acceptance criteria let the receiving team check behaviour without relying on verbal explanations.
- Operational runbooks explain how to respond when routine processes fail, including outside business hours.
- Data-reconciliation checks show whether the new system holds the same facts as the old one.
- Rehearsed rollback procedures record how long a rollback takes and whether it works in practice.
Fragmented ownership makes these records harder to assemble. Product context may sit in meetings, release responsibility may be unclear, and no one may own the entire path to production. Grail Computer Labs' delivery model addresses this pattern by keeping requirements, code, tests, approvals, monitoring and ongoing tickets connected during modernisation. Its application management services can support continued work on a platform after handover.
How an inherited platform gets its context back
Grail audits inherited code, data, infrastructure and product documents before rebuilding. The four steps are to map the whole platform, reconstruct how it worked, identify where changes could fail, and determine what it would take to run. The goal is to retain the useful data, business rules, workflows and operational knowledge while rebuilding the software around them.
Before the old team leaves, the handover should identify who can explain each undocumented behaviour, where that explanation is recorded, how the receiving team can verify it, and who owns it once the original author has moved on.
Lock-In and Exit Risk You Should Test Early
Portability is cheapest to test before you need it. After a provider becomes difficult to leave, the test becomes an incident.
A survey of 800 C-level leaders in the UK, US, Germany and the Netherlands found that 89% could not move business-critical workloads away from their largest provider within three weeks, and 55% said the move would take more than three months or was not currently feasible (reported survey findings on cloud exit). Those are leaders' estimates, not observed evacuation exercises, so treat them as a warning about confidence rather than a timetable.
The tests to run before committing
| Exit test | What to prove | Evidence to keep |
|---|---|---|
| Exportable data formats | Data can leave in open, documented formats | Exported sample that loads into another system |
| Provider-specific service dependencies | Which services need replacing and what that involves | Dependency list with replacement options |
| Infrastructure-as-code coverage | The environment can be rebuilt from code | Template that deploys to a clean account |
| Recovery environment | A restored workload can run outside the main provider | Timed restore record for each critical workload |
| Contract assistance | Exit help is available in writing | Signed clause or written statement of support |
| Time to validate a restored workload | How long a restored system takes to pass its tests | Rehearsal log with dates and results |
Run these as rehearsals rather than estimates. A restore that took four hours in a test environment tells you more about your exit risk than any architecture diagram, and paper estimates consistently flatter the actual figure.
Start with the most business-critical workload, because the result should shape the wave plan rather than arrive after it. If that workload can't be restored elsewhere, every later decision carries that constraint.
Ownership is the control that outlasts the contract. The business should hold the code, the cloud accounts, the models and the documentation, so an internal team or another provider can take over later without a negotiation.
Choose Move, Improve or Rebuild for Each Workload
Once the dependency map exists, choose a route for each workload: move it, improve it in place, or rebuild it. The right choice depends on the condition of the platform, not just the cost of moving it.
Improving a platform makes sense when its foundation can support the next stage, its production data and business rules are trustworthy, and failures are concentrated in identifiable parts. The release process must also be recoverable quickly. If those conditions do not hold, rebuilding may be the more realistic option, even when a move appears cheaper on paper.
A stable, well-understood workload that needs a new host can often move with fewer changes. Preserve its expected behaviour, then test that behaviour in the new environment. The dependency map, migration-period cost owner and exit test still belong in the plan.
Where the plan usually changes
A planned move can become a rebuild when the dependency map exposes undocumented core logic or a release process tied to one person's local environment. Finding that before scheduling the migration wave gives the team time to adjust scope and ownership.
If a platform already fails in production or a previous supplier has stopped delivering, the task may be software rescue: taking over the stalled work and getting it to production. A migration that has stalled mid-cutover needs the same workload-by-workload decision.
Test each route before committing resources. Survey figures describe patterns across programmes, not the likely outcome for any single platform.
Grail Computer Labs audits inherited platforms before deciding whether to improve or rebuild them, and invites teams to discuss systems they can no longer change safely. For organisations moving automated workflows into production, Grail also offers a guide to dividing responsibilities among IT, security and business operators.
Grail Computer Labs takes over stalled and inherited platforms, maps what is there, and rebuilds or re-platforms in controlled stages. If your migration has stalled around a system nobody can safely change, Grail Computer Labs can scope one measurable outcome in 4 to 8 weeks through an outcome engagement. Qualified clients can stop within the first 15 days without paying.