Application dependency mapping means recording every connection between your applications, servers, databases and outside services: what talks to what, in which direction, how often and why. Before a migration, it is what tells you which systems have to move together and which connections will break if they don’t. It is also the step most often cut short, because a server inventory feels like enough.
It isn’t. An inventory tells you what you have. A dependency map tells you what happens when you move one piece of it. This guide covers what to record, the methods that find dependencies (and what each one misses), and how to turn the map into move groups. It goes deeper on one part of a proper discovery phase.
What goes wrong without a map
The failures are rarely dramatic on the day. They show up a week later, when something that ran quietly stops running.
- The database stayed behind. An application moves to AWS while the database it shares with two other systems stays on-premises. Every query now crosses the link between the two, and pages that took half a second take several.
- The nightly job that nobody listed. A scheduled task pushes a file to a custodian or a bank every night. It ran from a server that was switched off after cutover, and the first sign is a call about a missing file.
- The hard-coded address. A configuration file points at an IP address rather than a name. The target moved; the address didn’t.
- The partner allowlist. A counterparty only accepts connections from your old public IP addresses. Changing that can take weeks of notice, and it was never in the plan.
Each one is cheap to find before the migration and expensive to find after it. Moving a system and then discovering its dependencies is a common reason migration timelines slip.
What to record for each dependency
A line between two boxes on a diagram is not enough to plan with. For each connection, record:
| Field | Example | Why it matters |
|---|---|---|
| Source and target | Client portal → shared SQL Server | Which systems are tied together |
| Direction and protocol | Outbound, TCP 1433 | Security group and firewall rules in AWS |
| Frequency and volume | ~400 queries per page; 2 GB a night | Whether latency or data transfer cost will bite |
| Business purpose | Portal reads client holdings | Whether the link is still needed at all |
| Owner | Head of client services | Who signs off a change |
| What breaks if it fails | Clients can’t see valuations | Priority, and the link to important business services |
| Address type | DNS name or hard-coded IP | Whether it survives the move unchanged |
The last two columns are the ones most often left blank, and they are the ones that decide the plan.
Four ways to find dependencies
No single method finds everything. Most mapping work combines at least three.
| Method | What it finds | What it misses |
|---|---|---|
| Server-level connection data (an agent on each server) | Live inbound and outbound connections, and the processes behind them | Anything that didn’t happen while the agent was running; servers you couldn’t install it on |
| Network data (firewall logs, flow records from switches or the hypervisor) | Traffic between hosts, including devices you can’t install agents on | Which application or process made the connection |
| Configuration and code review | Connection strings, hosts files, scheduled tasks, hard-coded addresses | Connections made at runtime that aren’t written down anywhere |
| Interviews with system owners and runbooks | Purpose, business impact, rare jobs, planned changes | Whatever people have forgotten or never knew |
Two rules apply whichever methods you use.
Observe across a full business cycle. A month at minimum, and long enough to include month-end. A reporting server that looks idle for three weeks may be the busiest machine in the building on the last working day. Quarter-end and year-end jobs are worth asking about directly.
Reconcile, don’t just collect. The useful findings are the mismatches: a connection seen on the network that no owner can explain, or a dependency an owner describes that the tools never saw.
Where AWS’s discovery tooling stands
AWS’s own discovery tools have changed. AWS Application Discovery Service closed to new customers on 7 November 2025; existing customers can keep using it, and AWS recommends AWS Transform, its newer AI-assisted migration service, for similar capabilities. Within Application Discovery Service, the older Discovery Connector for VMware stopped being supported on 17 November 2025, replaced by the Agentless Collector.
The distinction between agent and agentless still matters. AWS’s documentation notes that agentless collection through VMware vCenter cannot see the processes running inside each VM, which is exactly what you need to tell one application’s connections from another’s on a shared server. Our post on AWS Migration Hub alternatives covers the wider tooling change.
Tools make collection faster. They don’t tell you why a connection exists, whether it is still needed, or who to call when it breaks. Those answers come from people.
From map to move groups
The point of the map is to decide what moves together. A move group is a set of applications and servers that migrate in the same window because splitting them would hurt. Some working rules:
- Keep chatty pairs together. If two systems exchange many small requests, the round trip across a hybrid link adds up fast. Move them in the same group.
- Shared databases anchor a group. Everything that reads or writes a shared database either moves with it or gets a plan for how it will reach it afterwards.
- Start external changes early. Counterparty allowlists, payment scheme connections and file transfers with custodians often need weeks of notice. List them from the map on day one, not the week before cutover.
- Retire what the map shows is unused. A server with no inbound connections over a full month, and no owner who can explain it, is a candidate to retire rather than migrate.
Move groups then become migration waves: the order in which groups move, usually starting with ones that have fewer outside dependencies.
A worked example
(Illustrative.) A UK wealth manager plans to move 12 applications. Its inventory lists them as independent. Five weeks of mapping, combining agents, firewall logs and owner interviews, finds otherwise:
| Finding | Effect on the plan |
|---|---|
| The client portal, the CRM and the fee-billing system all use one SQL Server | All three and the database become one move group |
| The portal makes about 400 database queries per page | At an assumed 10 ms round trip across the hybrid link, that is about 4 seconds of waiting per page if the database stays behind |
| A month-end job sends valuation files to a custodian over SFTP from a fixed IP address | The custodian needs the new IP added to its allowlist, so the request goes in during week one |
| Two servers had no inbound connections in five weeks and no owner | Retired instead of migrated |
The original plan moved the portal first, on its own, because it looked simple. The map moved it into the largest group, and moved the custodian request to the start of the project.
The map is also a resilience document
For FCA-regulated firms, a dependency map does a second job. Operational resilience rules expect you to map the people, processes, technology and third parties behind each important business service. The map you build for migration is most of that work, so build it once and keep it current. Our guide to FCA operational resilience on AWS shows how the two fit together.
Mapping every workload and dependency before a price is set for moving anything is the core of a Yemberzal Cloud Migration Assessment.