Cloud Migration Risk Assessment: 6 Dependencies That Derail Projects
A practical cloud migration risk assessment guide. Learn to identify the six critical dependencies that derail projects before they even start.
On this page
- Overview
- Four Planning Assumptions That Break Cloud Migrations
- “It’s just lift-and-shift”
- “The app is stateless” (spoiler: nothing is)
- “Networking will figure itself out”
- “We’ll fix technical debt after we’re in the cloud”
- The Week-Zero Dependency Crawl (Tools and Outputs)
- Automated discovery: provider tools, specialist platforms, or a custom script
- Coupling score per bounded context (0–1 scale)
- Data gravity calculation in TB×ms
- The Six Dependencies That Commonly Sink Migrations
- #1 Hidden database fan-out and read replicas across VPCs
- #2 Active Directory / LDAP trusts that don’t exist in cloud IdP
- #3 License-bound Windows/SQL servers with no viable SaaS path
- #4 Mainframe batch schedules that assume 4 a.m. EST downtime windows
- #5 Compliance carve-outs (PCI, FedRAMP, DORA) that are quietly ignored
- #6 Change-averse business owners who weren’t in the room when the plan was sold
- The Pre-Flight Go/No-Go Checklist
- Can you roll back the entire wave in <4 hours?
- Is every external dependency dual-homed (DNS, certs, API keys)?
- Do you have a reconciled golden source of truth for config drift?
- When to abort, repatriate, or rewrite instead
- Coupling entropy >0.75 and no domain experts left → don’t migrate, retire
- License costs far above infrastructure → SaaS repurchase beats rehosting
- Business tolerates zero downtime but app has single-threaded file locks → rebuild
- Start with the map
Cloud migrations rarely fail on the move itself. They fail when a dependency nobody mapped, such as a shared database, an Active Directory trust, a license term or a batch schedule, surfaces after the project has started and invalidates the plan. Teams that map dependencies before cutover find these problems while they are still cheap to fix.
The framework below targets those blind spots: a week-zero dependency crawl, two scores that turn the raw map into decisions, six dependencies that commonly sink migrations, and a go/no-go checklist for cutover.
Four Planning Assumptions That Break Cloud Migrations
Migrations that go off the rails usually start with convenient assumptions, made in planning meetings to make a complex estate look simple. These assumptions feed budget overruns, security breaches, and failed projects. Test each one before the assessment begins.

“It’s just lift-and-shift”
"Lift-and-shift" suggests a simple copy-paste job from your on-prem data center to a cloud environment. It is never that simple.
A virtual machine humming along on VMware is not the same as an EC2 instance. The underlying networking, the storage I/O, and the hypervisor all behave differently. Applications tuned for the consistent, low-latency performance of an on-prem SAN can fall apart from I/O contention when moved onto cloud block storage without re-platforming.
The assumption skips over:
- Latency: A call between your app server and database that takes a fraction of a millisecond on-prem takes longer once the two sit in different availability zones (AWS describes single-digit-millisecond latency between zones in a region), and far longer if the database stays on-prem. Chatty applications that make thousands of small calls per request break first.
- Dependencies: Hard-coded IP addresses, a reliance on a specific hardware load balancer, and implicit network trust models all shatter the moment you "lift" the application.
- Cost: You're moving from a predictable capital expenditure (CapEx) model to an operational expenditure (OpEx) model that can spiral out of control.
“The app is stateless” (spoiler: nothing is)
No production application is truly stateless. When a team claims their app is stateless, it usually just means they haven't mapped out where the state is actually being managed.
Apps built on "stateless" principles still carry hidden stateful dependencies: in-memory caches that need to be repopulated after a restart, session data quietly stored on a local file system, or a reliance on a logging aggregator that assumes a persistent local agent. Move the app without accounting for this, and you get broken user sessions and silent data loss.
The most common failure point is assuming that because the application tier itself doesn't store persistent data, it has no state. State is hidden in logging configurations, session affinity settings on load balancers, and temporary file writes that were never meant to be permanent.
“Networking will figure itself out”
This is a symptom of organizational silos. Application teams assume the network team will replicate a decade's worth of complex on-prem firewall rules, routing tables, and VLAN segments in the cloud. It does not happen on its own.
Your legacy firewall ruleset likely has thousands of lines accumulated over years, with zero clear ownership or documentation. Trying to translate that mess directly into cloud security groups is both a technical problem and a security risk. The process forces a long-overdue review of traffic flows that almost always uncovers critical dependencies nobody knew existed.
Speed pressure makes this worse. Teams that rush to a cloud date tend to defer the firewall review, and multi-cloud estates multiply the rule sets to translate.
“We’ll fix technical debt after we’re in the cloud”
Postponing technical debt cleanup is among the most expensive decisions in a cloud migration. Moving a poorly architected, bug-riddled application to the cloud does not solve its problems. It makes them more expensive to run and harder to fix.
An inefficient on-prem application might chew up extra CPU cycles on hardware you've already paid for. In the cloud, that same inefficiency translates directly into a higher monthly bill. A monolithic application with tangled dependencies becomes impossible to scale or update, negating the agility the migration was meant to deliver.
Technical debt belongs in the risk assessment, not in a post-migration backlog.
The Week-Zero Dependency Crawl (Tools and Outputs)
Before you sign a cloud contract, build a high-fidelity dependency map. The quality of this week-zero discovery largely determines how the migration goes. The goal is the raw data a defensible, evidence-based cloud migration risk assessment needs, not a report.
Expose every hard-coded IP address, forgotten cron job, and chatty database connection that would otherwise break at 3 a.m. during cutover.

The goal is a map like this one: how every component talks to every other component, and where the data flows.
Automated discovery: provider tools, specialist platforms, or a custom script
You’ve got options, each with trade-offs in cost, accuracy, and engineering skill. Most teams reach for automated discovery tools first, which can be a good starting point but rarely tell the whole story.
| Method | Cost model | Key Advantage | Primary Limitation |
|---|---|---|---|
| Cloud provider discovery tools (AWS Application Discovery Service, Azure Migrate) | Free or bundled with cloud spend | Quick server inventory, utilization data and TCO modeling. | Often noisy, and weak on application-level dependencies that need manual cleanup. |
| Specialist dependency-mapping platforms | Commercial licenses | Deeper application-level analysis than native tools. | Licensing cost, and they still need configuration and validation. |
| Custom scripting (Python) | Engineering time | A context-aware map with exactly the data you need. | Requires skilled engineers who know what to look for and where. |
Commercial tools catalog what you have well, but a good script that queries CMDBs, parses netstat logs, and digs through config files often finds dependencies the tools miss.
Don't mistake a tool's dashboard for an assessment. Automated discovery is step one. The next step is translating the raw data into two metrics that guide the decisions below.
Coupling score per bounded context (0–1 scale)
This metric tells you how tangled an application is with other systems. A score of 0 is a completely decoupled service. A 1 is a monolith where everything depends on everything else.
To get this number, you count every unique inbound and outbound dependency (API calls, database connections, message queue topics, shared file systems).
- An application with five or fewer well-defined dependencies might score a 0.2, a perfect candidate for an early migration wave.
- An application with 50+ dependencies, including undocumented database links, could easily score a 0.9. This is a red flag: refactor or retire it rather than lift-and-shift.
Data gravity calculation in TB×ms
This number shows how strongly an application is tied to its data. Multiply the volume of data transferred (in terabytes) by the network latency incurred (in milliseconds).
For instance, in an illustrative case, an application that reads 2 TB of data from a database with 30ms of latency has a data gravity score of 60 TB×ms. If you move that application to the cloud and latency to its on-prem database jumps to 80ms, the performance penalty will be severe. The calculation exposes which components must move together, and a good cloud readiness assessment for your systems gives an honest read on these factors.
Coupling score and data gravity are the basis for the migration plan.
The Six Dependencies That Commonly Sink Migrations
The week-zero dependency crawl should surface six dependencies that commonly sink cloud migrations. They are predictable and high-impact, and a typical inventory misses them. A proper cloud migration risk assessment is designed to find them before cutover.

#1 Hidden database fan-out and read replicas across VPCs
This is the classic technical failure. You think you're migrating a single application with one tidy database. Your discovery map, however, tells a different story: that "single" database is the backbone for ten undocumented apps and five read replicas scattered across network segments.
Move the primary database without its dependents and latency spikes, because those services now reach it across the new cloud network boundary. The fan-out creates so much data gravity that you cannot move one piece without disrupting the rest.
How to spot it: Look for a suspiciously high number of distinct IP addresses hitting your database ports. Your data gravity calculation (TB × ms) will be high for this one component.
#2 Active Directory / LDAP trusts that don’t exist in cloud IdP
Many on-prem apps, especially older .NET and Java systems, were built assuming they could lean on complex, multi-domain Active Directory (AD) trusts for authentication.
These brittle trust relationships often have no clean equivalent in cloud-native Identity Providers (IdPs) like Azure AD (now Entra ID) or Okta. The migration team says, "we'll just use SAML," only to find the app doesn't speak it. Even worse, you discover the app depends on Kerberos delegation (a feature notoriously painful to replicate in a hybrid cloud setup). This single dependency can halt the migration of an entire application portfolio.
#3 License-bound Windows/SQL servers with no viable SaaS path
This risk is financial, not technical. You might have a perpetual license for Windows Server or SQL Server that’s perfectly happy in your data center. But that license might not be portable to a public cloud without triggering a massive new bill.
Cloud providers have their own licensing rules, and bringing your own license (BYOL) isn't always an option. Your migration's Total Cost of Ownership (TCO) can change sharply if you're forced to pay for new, consumption-based licenses, and for database and Windows workloads the license line can outweigh the infrastructure line.
An effective risk assessment evaluates technical feasibility and models license cost. As a rule of thumb, if projected license costs are several times the infrastructure costs, rehosting is probably the wrong move.
#4 Mainframe batch schedules that assume 4 a.m. EST downtime windows
Mainframe apps operate on a rigid schedule of batch jobs optimized over decades. These jobs often assume they have exclusive, bare-metal access to system resources during a specific window, like 4 a.m. EST.
When you move the surrounding applications to the cloud, you shatter this assumption. The new, distributed architecture introduces network latency and timing jitter that cause batch windows to be missed, leading to data corruption and business process failures. You can’t just lift-and-shift a component that relies on a monolithic processing schedule. For more on these dependencies, see these best practices for data migration.
#5 Compliance carve-outs (PCI, FedRAMP, DORA) that are quietly ignored
Your company might be fully compliant with PCI, FedRAMP, or DORA on-premises, but that compliance certificate doesn't automatically transfer to the cloud. These frameworks have specific requirements for data residency, encryption, and network segmentation that are implemented completely differently in AWS, Azure, or GCP.
Misconfiguration is a leading cause of cloud security incidents. It usually happens because teams fail to map old compliance boundaries to new cloud-native controls before they start migrating, leading to accidental data exposure.
#6 Change-averse business owners who weren’t in the room when the plan was sold
The final risk is political. The migration plan got the green light from the CIO and the board. But the person who actually owns the application (the one whose bonus depends on its stability) was never truly bought in.
At the first hiccup during user acceptance testing, this owner is likely to halt the launch. They’ll use any disruption as "proof" that the migration is too risky and demand a full rollback. An owner who wasn't in the room and sold on the "why" from day one becomes the biggest obstacle.
The Pre-Flight Go/No-Go Checklist
A project plan is theory until readiness is verified. This checklist is the final check before cutover. Answering 'no' to any item is a signal to halt the launch.
Can you roll back the entire wave in <4 hours?
The first gate is the rollback plan. If you can't retreat cleanly, don't advance.
- Treat a four-hour rollback window as the target. A theoretical "yes" doesn't count: rehearse it, time it, and prove it.
- A 300-step Word document is a recipe for human error at 2 a.m., not a rollback plan. Your rollback should be as automated as your deployment.
- You must prove you can reverse the data flow without corrupting the on-premise source of truth. Most rollbacks fail here.
A migration without a rehearsed, timed, and automated rollback capability is just an outage with a project plan.
Is every external dependency dual-homed (DNS, certs, API keys)?
The moment the application comes online in the cloud, it has to reach external services. Small oversights here can take the whole application down.
| Category | Go/No-Go Question | Why It Sinks Migrations |
|---|---|---|
| DNS & Certificates | Is every external dependency (APIs, load balancers) dual-homed and tested? | A single forgotten DNS entry or an SSL certificate that's off by one day can make your entire application unreachable. |
| Secrets Management | Are all API keys, service accounts, and database credentials centrally managed and tested? | Hard-coded credentials in config files are a classic cause of "it worked in staging" failures. They break the instant they hit production. |
| Configuration Drift | Do you have a reconciled "golden source of truth" for configuration? | Without a Git repo or similar system, your new cloud environment will become an untrusted black box within weeks. |
| Monitoring & Alerting | Is every critical health check and alert configured and tested before cutover? | You must have confirmed alerts for CPU, memory, and error rates before a single real user hits the system. |
Do you have a reconciled golden source of truth for config drift?
The configuration-drift row above is the item to settle here: keep a reconciled source of truth for configuration, in Git or a similar system, and check the deployed environment against it before cutover. Across all four rows, the checklist demands planning effort that pays off during execution, and it targets the most common sources of Day 1 failure. It is also the check that shows whether your cloud migration risk assessment worked.
When to abort, repatriate, or rewrite instead
Not every application belongs in the cloud. A successful cloud migration risk assessment finds problems to fix and also identifies workloads that should be stopped, repatriated on-prem, or rewritten instead. Make those calls early, based on facts.
This decision tree shows the go/no-go gates for rollback plans, configuration readiness, and dependency mapping.

A "no" at any of these checkpoints calls for re-evaluation before more money is spent.
Coupling entropy >0.75 and no domain experts left → don’t migrate, retire
Your dependency map should generate a coupling score for each application. Once that score climbs above a threshold you set up front (this guide uses 0.75), you're looking at a highly entangled system. The deciding factor is a high score combined with no remaining domain experts. If the engineers who built the system are long gone, your team is unlikely to untangle the dependencies without breaking undocumented business logic.
The Verdict: Retire the application. The risk of failure is too high. Decommission it and replace its functionality.
License costs far above infrastructure → SaaS repurchase beats rehosting
This one is arithmetic. A lift-and-shift can trigger large new licensing costs, so model them carefully. If projected annual licensing fees dwarf the cost of the underlying cloud servers (a working threshold is roughly 3×), the migration fails financially.
The Verdict: Repurchase as SaaS. Stop the rehosting plan. The Total Cost of Ownership (TCO) is inverted. A SaaS alternative usually delivers better value.
Business tolerates zero downtime but app has single-threaded file locks → rebuild
Here a business requirement collides with a technical limit. The business demands zero downtime during cutover, but the assessment finds a core process that depends on single-threaded file locks or in-memory state that can't be replicated. That makes a seamless migration impossible.
The Verdict: Rewrite. The current architecture cannot meet the business's resilience requirements in a cloud model. A full rewrite is the path forward. For more on what that involves, see cloud architecture in our detailed guide.
Start with the map
Start the migration with a complete map of every dependency that can fail and when each one will be touched. Draw that map first.
The thresholds in this guide (coupling score, license-to-infrastructure ratio, rollback window) are working rules of thumb. Set your own from your estate and risk tolerance. The worked numbers are illustrative.
Chief Analyst, Software Modernization Intelligence · 10+ years B2B market research
Published: ·Updated: