Project Dependency Mapping: A Step-by-Step Method
Learn project dependency mapping in six steps: find internal and external blockers early, rate their risk, and sequence work so nothing stalls.
Project dependency mapping means listing everything your project needs from other people, teams, vendors, and earlier tasks, then arranging the work around what has to happen first. Do it in six steps: gather the work, find the dependencies, record them in one register, rate each by lead time and risk, find the critical path, and assign an owner and a due date to every item. Done before you commit to a date, it turns surprise blockers into scheduled tasks.
Why dependencies break plans
Most missed deadlines are not caused by slow work. They come from work that could not start because something else had not arrived. A contract waiting on legal, a data export waiting on one engineer, an app review that takes five days when you budgeted one.
Two things make this worse in small organizations. First, people are shared. The same person who owns your migration also covers support, so a dependency on "engineering" is really a dependency on one human's calendar. Second, nobody owns the gaps between teams. Each person plans their own tasks well and assumes the handoffs will sort themselves out.
A dependency map makes the handoffs visible. It does not make them go away, but it tells you which ones to start on first.
The four types of dependencies
You will find it easier to hunt for dependencies if you know the shapes they take.
- Task dependencies: Task B cannot start until task A finishes. Copy cannot be finalized until the design is approved.
- Resource dependencies: Two tasks need the same person, tool, or budget. Nothing is technically blocked, but both cannot happen at once.
- Approval dependencies: A decision or sign-off from someone outside the working team. Legal review, security review, a budget release, a client's go-ahead.
- External dependencies: Anything a vendor, partner, regulator, or customer controls. Payment processor onboarding, a partner's API, a permit, a customer's data file.
Task dependencies are the ones people list naturally. The other three are where projects get hurt, because they sit outside the plan and often outside your control.
Step-by-step: how to map project dependencies
Step 1: Break the project into work you can see
You cannot find dependencies between tasks you have not named. Start with the deliverables, then break each one into tasks of roughly one to five days. If a task is "launch marketing," it is too big. If it is "write the three-email announcement sequence," it is right.
If you already have a project roadmap, use it as the starting list. If you do not, a simple roadmap template will give you the skeleton in an hour. Aim for 20 to 60 tasks on a typical small project. More than that, and you are probably mapping at the wrong level.
Step 2: Ask the three dependency questions for every task
Go through the list one task at a time and ask:
- What must exist or be decided before this can start?
- Who or what outside this team do we need for it?
- What does this task produce that someone else is waiting for?
The third question matters most and gets asked least. It finds the dependencies where your team is the blocker, which is the part of the map other teams care about most.
Do this in a room with the people who will do the work, not alone. One person's list will miss roughly a third of what the group finds. The designer knows which assets are late. The engineer knows the staging environment is shared. The account manager knows the client takes a week to reply to anything.
Step 3: Put every dependency in one register
A register is a flat list, one row per dependency. Keep it in a spreadsheet the whole team can see. This is the template:
| Dependency | Type | Needed by | Provider (owner) | Lead time | Risk | Status |
|---|---|---|---|---|---|---|
| Payment processor approval | External | Wk 5 | Processor / Dana | 4 weeks | High | Not requested |
| Updated terms of service | Approval | Wk 6 | Outside counsel / Sam | 2 weeks | Medium | Not requested |
| Billing data export | Task | Wk 3 | Priya (shared) | 3 days | Medium | Scheduled |
| Brand tokens from contractor | External | Wk 2 | Contractor / Lee | 1 week | Low | Requested |
The columns that matter are "Needed by," "Provider," and "Lead time." Without them you have a list of worries, not a plan. Name a single person as the owner of each row, even when the provider is outside the company. That person is the one who chases.
Step 4: Rate each dependency by lead time and risk
Not every dependency deserves the same attention. Score each one on two things.
- Lead time: How long does it take from asking to receiving? Be honest. Use the provider's real turnaround, not the one you hope for.
- Risk: How likely is it to slip, and how much would a slip hurt? A vendor you have never worked with and who has a history of slow replies is high risk. A teammate sitting next to you is low.
Anything with a long lead time and high risk goes to the top. If you keep a risk register, move the high-risk dependencies into it so they get reviewed on a schedule instead of forgotten.
Step 5: Find the critical path and sequence backward
The critical path is the longest chain of dependent tasks from start to finish. If anything on it slips, the end date slips. Everything off the path has slack.
To find it, work backward from the launch date. Take the final deliverable, list what it needs, then what those need, and add up the durations along each chain. The longest chain is your critical path.
Then apply one rule: start the long-lead items first, even if they feel premature. Request the approval, send the vendor questionnaire, book the legal review, and reserve the shared engineer's time before you finish the design. Work that waits on other people should be queued as early as possible, because the waiting happens in parallel with your own work.
Step 6: Assign owners, dates, and a check-in rhythm
A map nobody reviews is decoration. For each row, confirm three things with the owner: the date it is needed, the date the provider has actually agreed to, and the date you will check.
Bring the register to your project kickoff meeting and ask each provider's counterpart to confirm their dates out loud. Then review the "Not requested" and "At risk" rows for five minutes in every weekly meeting. That is the whole maintenance routine.
Worked example: a billing feature for a 9-person SaaS company
A software company with about $1.2M in annual recurring revenue wanted to launch self-serve billing. Today, 300 customers pay by invoice, and finance spends roughly 12 hours a week on manual billing. The goal was to launch in 8 weeks and move at least 40 customers to card payments in the first month, adding about $15,000 in monthly recurring revenue from annual-plan upgrades.
The first plan looked like this: two weeks of design, five weeks of build, one week of QA, launch at week 8. The team was one designer, two engineers (one of whom also covered support), a product lead, and a finance manager.
When the product lead ran the dependency questions with the team, five items surfaced that were not on the plan:
- The payment processor needed a business review before live transactions. Its stated turnaround was 3 to 4 weeks, and nobody had applied.
- The terms of service needed a clause on automatic renewals. Outside counsel needed two weeks.
- The billing data export depended on the one engineer who also owned support, and her calendar was 60% committed to tickets.
- Brand assets for the checkout page were with an outside contractor who replied slowly.
- The announcement email needed the final pricing page, which depended on the finance manager's decision on annual discounts.
On the original plan, the processor application would have gone in around week 5, when the build was "close." Four weeks of review would put approval at week 9 and launch at week 10, with the team idle for part of week 8. Two weeks of delay at the target rate cost roughly $7,500 in revenue that would otherwise have started sooner, plus the awkwardness of a customer announcement that had to be pushed.
The fix cost almost nothing. The processor application went in on day two. Counsel got the terms request in week 1. The product lead booked the engineer's export work for week 3 and moved her support rotation to the other engineer for three days. The finance manager committed to the discount decision by week 4.
The critical path turned out to be processor approval, then integration testing, then launch, a chain of about 7.5 weeks. Build and design had slack. The team launched in week 8, as planned, and moved 46 customers in the first month.
Nothing about the work got faster. The team just stopped finding out about waiting time at the end.
A common mistake: mapping only what your team controls
The most frequent failure is a map that lists tasks the team does and ignores the waiting time between them. It looks tidy, and it hides the exact risks you needed to see.
You can spot this mistake when every dependency in the register has an internal owner and a lead time of "1 day." Real projects have vendors, approvers, and customers, and they do not respond in a day.
To avoid it:
- Add an "External or approval" column and make sure it is not empty.
- Ask each provider directly for their turnaround instead of estimating it yourself.
- Add a buffer of 25 to 50% to any lead time from a provider you have not worked with before.
- Put "who else needs to say yes?" on the planning agenda as its own item.
A second mistake is treating the map as a one-time exercise. Dependencies change as scope changes. If your project is growing, scope creep will add new rows faster than you expect, so re-run the three questions whenever scope shifts.
Handling resource dependencies
Resource dependencies are the quietest kind. Nothing is blocked on paper, but two tasks need the same person in the same week.
Look at your map and count how many tasks name each person in a given week. If one person appears on more work than their available hours allow, you have a hidden dependency. The fix is either to move one task, add help, or accept the delay knowingly. A short capacity check will show you the numbers. Do this before you finalize dates, not after.
When a dependency cannot be moved
Sometimes the provider will not give you a faster date. You still have four options:
- Start earlier: Pull the request forward, even if the rest of the project is not ready.
- Decouple: Rebuild the plan so the blocked piece is not on the launch path. Ship without it, or ship a smaller version.
- Substitute: Use a different vendor, tool, or process with a shorter lead time.
- Escalate: If a dependency inside your company is stalled, take it to the person who can set priorities between teams. Bring the register and the cost of delay in dollars or days.
Pick one, tell the team, and update the map. Avoid the fifth option, which is hoping.
How much mapping is enough
For a project of two to three months and a team under 15 people, one hour for the first session and five minutes a week afterward is enough. Do not build a network diagram with every arrow unless the project has more than about 60 tasks. A register plus a short list of the three or four items on the critical path covers nearly everything.
If your team prefers visual boards, the choice between timelines and cards matters less than whether dependencies are visible. A comparison of Gantt charts and Kanban boards can help you pick, but either one works as long as blocked items are marked.
Key takeaways
- Map dependencies before you commit to a date. A register with owner, needed-by date, and lead time takes about an hour and prevents most late surprises.
- Ask three questions of every task: what does it need, who outside the team is involved, and who is waiting on it.
- Look beyond task order. Approvals, external providers, and shared people cause most of the real delays.
- Find the critical path by working backward from the launch date, then start long-lead items first even when they feel early.
- Get turnaround times from providers directly and add a buffer for anyone you have not worked with.
- Review the register for five minutes in every weekly meeting, and update it whenever scope changes.
Frequently asked questions
- What is project dependency mapping?
- It is the practice of listing every task, person, approval, or outside deliverable that your work needs before it can start or finish, then showing how they connect. The result tells you what to start first and where a delay will spread.
- How early should you map dependencies?
- Before you commit to a date. Map them during planning, then review the map at kickoff and again in every weekly check-in. Dependencies found in week one cost a conversation; dependencies found in week eight cost a deadline.
- What is the difference between internal and external dependencies?
- Internal dependencies sit inside your organization, such as another team's output or a shared engineer. External dependencies sit with vendors, regulators, customers, or partners, and they usually have longer lead times and less flexibility.
- Do you need software to map project dependencies?
- No. A spreadsheet with one row per dependency and a simple diagram on a whiteboard is enough for most teams under 50 people. Move to a tool only when the number of linked tasks makes manual updates unreliable.
Related playbooks
Risk Register Template: How to Build and Use One
A simple risk register template with likelihood, impact, owner and mitigation columns, plus a 15-minute weekly habit that keeps it current and useful.
How to Run a Project Kickoff Meeting: Step-by-Step Guide
Run a project kickoff meeting that locks in scope, owners, risks, and success criteria. Includes a pre-work checklist, 60-minute agenda, and example.
How to Write a Project Brief Template That Aligns Teams
A lean project brief template with five elements that stop scope misalignment before work starts. Includes a realistic worked example and the most common mistake to avoid.
Gantt Chart vs Kanban Board Planning: Which to Use
Learn when to use a Gantt chart vs a Kanban board for project planning. Side-by-side comparison, a worked example, and a 3-question decision rule.