From Project Plans to Dependency Graphs
Your project plan says the migration rehearsal starts Thursday. Security sign-off is due Tuesday, the application programming interface (API) contract is “almost done,” and the observability dashboard has an owner. Every line has a date. Yet no one can answer a more important question: what must cross from one team to another before Thursday can actually happen?
A date-based plan can show intended sequence without showing the handoffs that make the sequence possible. A dependency graph adds that missing view.
In this guide, a dependency is work, evidence, or a decision that relies on another item or party. An interface is the contract or handoff between two work items—for example, an API contract, test result, dashboard, or sign-off. A dependency graph is a map of work items and the links between their upstream inputs and downstream consumers.
The graph is a coordination tool, not proof of causality and not a guaranteed critical-path calculation. PMI's program-management standard frames program work around coordinated management and benefits that would not be available from managing components separately; that makes cross-component interfaces worth inspecting explicitly ([PMI](<https://www.pmi.org/standards/program-management-fifth-edition>)).
Start with one decision-sized slice
Do not graph the entire portfolio first. Choose one upcoming outcome that requires several teams, such as “run the migration rehearsal on Thursday.” Then list the deliverables or decisions that must exist for that outcome to proceed.
For each item, record seven fields:
- Upstream input: What must arrive first?
- Downstream consumer: Who or what uses it?
- Interface: What exactly crosses the boundary?
- Owner: Who is accountable for producing or accepting it?
- Evidence: What proves the handoff is usable?
- Needed-by date: When does the consumer need it—not merely when the producer hopes to finish?
- Decision or review trigger: What happens if evidence is absent or rejected?
These fields matter because “Team A depends on Team B” is too vague to review. The interface and evidence make the relationship testable; the consumer and needed-by date expose the operational consequence; the trigger routes a missing handoff to a decision.
Draw links from producer to consumer
Represent each deliverable or decision as a node. Draw a directed link from the upstream producer to the downstream consumer. Label the link with the interface and its evidence.
For example:
API contract → integration build → migration rehearsal
The arrow does not mean one team controls the next. It means the downstream item cannot be accepted until a named interface crosses the boundary.
Then classify each link:
- Hard: the consumer cannot proceed without it, such as a required security approval.
- Soft: work can proceed temporarily with an agreed assumption or stub, but the gap must close later.
- External: the producer sits outside the immediate program, such as a vendor or regulator.
- Informational: the item changes a decision or level of confidence but does not mechanically stop the next task.
This taxonomy is an editorial recommendation, not a universal PMI classification. Adapt the names to your governance model; preserve the practical distinction in the review action.
Hypothetical example: preparing a service launch
The following service-launch example is hypothetical. It is not a customer story and makes no performance claim.
A team wants to run a migration rehearsal on Thursday. Four items appear in the plan:
- API contract
- security sign-off
- observability dashboard
- migration rehearsal
The plan shows dates and owners. The graph shows the interfaces:
- The platform team publishes the API contract. The application team consumes it in the integration build. Evidence is an acknowledged contract version and a passing contract test.
- Security reviews the documented data flow. The launch lead consumes the sign-off before approving the rehearsal. Evidence is the linked decision record.
- The reliability team provides an observability dashboard. The rehearsal team consumes it to judge whether the migration can be observed and reversed. Evidence is a dashboard review using test telemetry.
- The integration build, security sign-off, and reviewed dashboard all feed the migration-rehearsal decision.
Now inspect the path rather than the status colors. Suppose the dashboard exists and security has approved the data flow, but the application team has not acknowledged the latest API contract. The blocking path is not “platform work is amber.” It is:
unacknowledged API contract → no accepted integration build → rehearsal decision lacks evidence
That statement gives the review a next move: the application owner must accept or reject contract version 7 by Wednesday noon. If no response arrives, the launch lead decides whether to move the rehearsal or use the agreed stub.
The graph did not predict the schedule. It exposed the missing interface, consumer, evidence, and decision.
Look beyond the longest chain
Teams often equate dependency review with critical-path review. The longest chain matters, but interfaces can fail elsewhere.
A short external link may carry more uncertainty than a long internal chain. A soft dependency can become hard when an assumption expires. An informational link can alter the launch decision even when no task is mechanically blocked.
Review each interface with four questions:
- Is the producer's output defined clearly enough for the consumer to accept or reject it?
- Is the evidence stored where the consumer can inspect it?
- Does one owner have the authority to resolve rejection or delay?
- Is there a trigger that turns waiting into a decision?
PMI's program-management standard is useful context for coordinating related components, but it does not prove that this specific graph format improves delivery ([PMI](<https://www.pmi.org/standards/program-management-fifth-edition>)). Treat the template as an operating hypothesis and inspect what happens.
Avoid four common mistakes
Graphing teams instead of deliverables. “Security → Platform” hides the actual handoff. Label the contract, decision, or evidence.
Using completion as acceptance. A producer can mark an item done while the consumer still cannot use it. Record consumer acknowledgement or a test result.
Assigning an owner without a decision route. Ownership does not help when the owner lacks authority. Add the escalation trigger and decision owner.
Maintaining the picture after it stops changing decisions. If every review repeats the same graph without new evidence, narrow it to the interfaces that can alter the upcoming outcome.
Use DORA measures as later outcome checks
DORA defines software-delivery measures including change lead time, deployment frequency, failed-deployment recovery time, change-fail rate, and deployment rework rate ([DORA metrics guide](<https://dora.dev/guides/dora-metrics/>)). DORA's research discusses these measures as a way to understand software-delivery performance ([2023 DORA report](<https://dora.dev/research/2023/dora-report/2023-dora-accelerate-state-of-devops-report.pdf>)).
If you introduce dependency-graph reviews, choose a relevant measure before the change and observe it over time. For example, if the method is meant to improve interface readiness before releases, you might watch change lead time and failed-deployment recovery time alongside local measures such as rejected handoffs or missed evidence dates.
Do not claim that the graph caused any movement in those measures. Team composition, architecture, release volume, tooling, and many other factors can change at the same time. DORA is an outcome-check framework here, not causal proof.
A reusable dependency review
For the next cross-team milestone:
- Name the outcome and its decision date.
- List only the deliverables and decisions needed for that outcome.
- Connect each upstream producer to a downstream consumer.
- Label every interface and the evidence that proves acceptance.
- Classify hard, soft, external, and informational links using your team's definitions.
- Trace the current blocking path.
- Name the missing evidence, responsible owner, decision owner, and next trigger.
- Remove links that no longer affect the decision.
- Select any outcome measure before changing the process, and interpret it cautiously.
A project plan tells you what the team intends to do. A dependency graph helps the team inspect whether the handoffs required to do it are actually ready.
Source record
- [PMI, The Standard for Program Management — Fifth Edition](<https://www.pmi.org/standards/program-management-fifth-edition>)
- [DORA metrics guide](<https://dora.dev/guides/dora-metrics/>)
- [DORA 2023 report](<https://dora.dev/research/2023/dora-report/2023-dora-accelerate-state-of-devops-report.pdf>)
Member discussion