Project Network Diagrams Explained
Behind every Gantt chart there is a quieter picture that decides where the bars land: the project network. It maps each activity and the links between them, then runs two simple sweeps to find the earliest and latest each task can happen. From those numbers fall the float, the critical path, and the bars you actually see. This guide walks through the precedence diagramming method, the four dependency types, and a worked forward and backward pass on a small real network.
What a network diagram really is
A project network diagram is a map of the logic in your plan. It strips away the calendar and the bars and shows only two things: the activities that make up the work, and the dependencies that say which activity has to wait for which. Everything else in scheduling, including the dates on a Gantt chart, is computed from that map.
The value of drawing it is that logic errors become obvious. A missing link, a task that depends on nothing, a loop where two tasks each wait for the other: these hide easily in a list of dates but stand out at once in a network. Get the network right and the schedule almost builds itself. Get it wrong and no amount of careful date entry will save the plan.
Two notations, one survivor
Historically there were two ways to draw a network. The older activity-on-arrow method put activities on the arrows and used nodes as connection points. It was fiddly, often needing invisible dummy arrows just to express certain links, and it has largely disappeared from modern practice.
The method that won is activity-on-node, better known as the precedence diagramming method, or PDM. In PDM each activity is a box, or node, and each arrow is a dependency between two activities. Every scheduling tool you are likely to touch today uses PDM under the hood, so it is the notation worth learning. The rest of this guide is entirely about it.
Nodes as activities, arrows as dependencies
In PDM the node carries the work. A node holds the activity name and its duration, and once the passes are run it also holds four computed dates plus the float. The arrow carries the rule. An arrow drawn from activity A to activity B says B depends on A, so B cannot happen freely until A has done its part.
Read that direction carefully, because it is the whole grammar of the diagram. The tail of the arrow is the predecessor. The head is the successor. A node with no incoming arrows can start immediately. A node with no outgoing arrows is a finish point of the project. The shape of the network is simply the set of all these predecessor and successor relationships drawn at once.
The four dependency types
Not every dependency is the plain "finish this, then start that" link. PDM supports four types, defined by which end of the predecessor connects to which end of the successor. Finish-to-start is by far the most common, but the other three exist because real work overlaps.
| Type | Rule | Everyday example |
|---|---|---|
| Finish to start (FS) | Successor starts after predecessor finishes | Pour the foundation, then build the walls |
| Start to start (SS) | Successor starts after predecessor starts | Begin paving once grading has begun |
| Finish to finish (FF) | Successor finishes after predecessor finishes | Testing wraps only when coding wraps |
| Start to finish (SF) | Successor finishes after predecessor starts | Old shift ends once the new shift starts |
For a deeper tour of when each one earns its place, see the guide on task dependencies. For the worked pass below we use only finish-to-start links, which keeps the arithmetic clean while showing the whole method.
Building the network step by step
You do not need special software to sketch a network. A whiteboard and sticky notes work, and the discipline of doing it by hand often surfaces missing logic. The sequence is always the same.
- List every activity that has to happen, one per node, with an honest duration on each.
- For each activity, ask what must be done before it can begin, and draw an arrow from each of those predecessors into it.
- Check that at least one node has no predecessor, so the network has a start, and at least one has no successor, so it has an end.
- Scan for loops, where following the arrows brings you back to where you started, and break any you find, because a network cannot contain a cycle.
- Run the forward pass to get the earliest dates, then the backward pass to get the latest dates.
- Subtract to get the float, and mark the zero-float chain as your critical path.
Steps five and six are the mechanical heart of the method, so the next two sections walk through them on a concrete example.
The forward pass: earliest dates
The forward pass sweeps left to right and answers the question, how soon can each activity happen? It produces two numbers per node: the early start (ES) and the early finish (EF), where EF is simply ES plus the duration. The rule for ES is that an activity cannot start until every predecessor has finished, so its ES is the largest EF among the activities feeding it.
The network. Six activities: A Requirements (3 days), B Design (4, after A), C Backend (6, after B), D Frontend (5, after B), E Integrate (3, after C and D), F Launch (2, after E). Counting from day 0, each early finish is its early start plus its duration.
Sweeping forward. A starts at 0 and finishes at 3. B starts at 3, finishes at 7. B then feeds both C and D, so each starts at 7: C finishes at 13, D finishes at 12. E waits for the later of C and D, so its start is 13, not 12, and it finishes at 16. F starts at 16 and finishes at 18.
The result. The whole project needs 18 days. That single number, the largest early finish in the network, is the shortest time in which the work can possibly be done.
The backward pass: latest dates
The backward pass sweeps right to left and answers the mirror question, how late can each activity happen without pushing out the finish? It produces the late finish (LF) and late start (LS), where LS is LF minus the duration. You seed it by setting the final activity's LF equal to its EF from the forward pass, then work back. The rule for LF is that an activity must finish before its earliest successor needs to start, so its LF is the smallest LS among the activities that depend on it.
Seeding the end. F is the finish, so its LF equals its EF of 18, and its LS is 16. E must finish before F starts, so E has LF 16 and LS 13.
Working back through the branch. Both C and D feed E, so each takes LF 13. C, at 6 days, has LS 7. D, at 5 days, has LS 8. B feeds both C and D, so its LF is the smaller of their late starts, that is 7, giving B an LS of 3. A feeds B, so A has LF 3 and LS 0.
What the gap reveals. D can start as late as day 8 but as early as day 7, so it has room to slide. Every other activity has its late start equal to its early start, meaning it has none.
Float and the critical path
Float, sometimes called slack, is the reward for doing both passes. For any activity it is the late start minus the early start, which equals the late finish minus the early finish. It is the amount of time the activity can slip before it delays something downstream. Any activity with zero float sits on the critical path, the longest chain through the network and the sequence that sets the project length.
| Activity | Duration | ES | EF | LS | LF | Float | Critical |
|---|---|---|---|---|---|---|---|
| A Requirements | 3 | 0 | 3 | 0 | 3 | 0 | Yes |
| B Design | 4 | 3 | 7 | 3 | 7 | 0 | Yes |
| C Backend | 6 | 7 | 13 | 7 | 13 | 0 | Yes |
| D Frontend | 5 | 7 | 12 | 8 | 13 | 1 | No |
| E Integrate | 3 | 13 | 16 | 13 | 16 | 0 | Yes |
| F Launch | 2 | 16 | 18 | 16 | 18 | 0 | Yes |
The critical path is A, B, C, E, F, whose durations add to 18. D is the only activity with slack, one day of it, because the backend it runs alongside takes a day longer. The wider theory behind these numbers lives in the guide on the critical path method, and the meaning of the slack itself in the guide on float.
How the network underlies the Gantt chart
A Gantt chart is a picture of the forward pass. Each bar is drawn from an activity's early start to its early finish, and the vertical stack of bars is just the nodes listed down the page. The dependency arrows you drag between bars in a Gantt tool are the same arrows as in the network, only bent to follow the timeline. When you move one bar and the ones after it shift, you are watching a forward pass recompute in real time.
This is why a Gantt chart that ignores dependencies is so fragile. Without the network beneath it, the bars are just decorated dates that never react to change. With the network, they behave like a model. You can build that living version, links and all, in the free Gantt maker and watch a slip cascade the moment you enter it.
How the network underlies the critical path
The critical path is not something you draw. It is something the network computes, then you read off. Once the two passes are done, the critical path is simply every node whose float is zero, joined tail to head. In our example those nodes form one unbroken chain, but larger networks can have several critical paths at once, or a near-critical path with a single day of float that becomes critical the instant an estimate grows.
Because the path falls out of the float, it moves when the logic or the durations move. Shorten the backend and the frontend might become critical instead. This is the payoff of thinking in networks rather than bars: the diagram does not just show today's critical path, it tells you which chain would take over next if reality shifts.
Common mistakes that break a network
Most broken networks fail for a handful of repeatable reasons, and all of them are easy to catch once you know the pattern. A quick review against this list before you trust the dates will save you from a plan that computes a confident but wrong answer.
| Mistake | Symptom | Fix |
|---|---|---|
| Dangling activity | A node with no predecessor or no successor mid-plan | Add the missing link so it joins the flow |
| Hidden loop | The tool refuses to schedule or hangs | Find the cycle and remove one wrong arrow |
| Date instead of logic | Bars that will not move when a predecessor slips | Replace the fixed date with a real dependency |
| Over-linking | A tangle of arrows nobody can read | Keep only the links that are truly required |
The worst of these is the third, a hard date standing in for a dependency, because it produces a plan that looks finished yet quietly stops reacting to change. A Gantt chart built once and never touched is not a plan, it is a wish.
From diagram to a living plan
The network is not a document you draw once and file. It is the engine that keeps the schedule honest, and it only earns its keep if you let the two passes run again every time an estimate or a link changes. In a good tool that happens automatically the moment you edit a duration or drag a dependency, which is exactly why building your plan on real logic beats typing in dates by hand.
Start from the logic, not the calendar. List the activities, draw the arrows, run the passes, and read off the critical path. Do that and the dates take care of themselves, the float tells you where you have room, and the critical path tells you where you do not. That is the whole quiet power of the precedence network sitting under every Gantt chart you will ever build.
Templates that use this
Keep reading
- Critical Path Method (CPM): Steps, Formula & Example
- Gantt Chart Dependencies Explained: FS, SS, FF and SF
- What Is Float (Slack) in a Project Schedule?
Frequently asked questions
What is the difference between a network diagram and a Gantt chart?
A network diagram shows pure logic: activities as nodes and dependencies as arrows, with no timeline. A Gantt chart places those same activities on a calendar as bars. The network computes the dates through its two passes, and the Gantt chart displays the result, so they are two views of one plan.
What does the precedence diagramming method mean?
The precedence diagramming method, or PDM, is the activity-on-node way of drawing a project network. Each activity is a box and each dependency is an arrow between boxes. It replaced the older activity-on-arrow style and is the notation every modern scheduling tool uses beneath its Gantt view today.
How do the forward and backward pass work together?
The forward pass sweeps left to right to find the earliest each activity can start and finish. The backward pass sweeps right to left to find the latest each can happen without delaying the project. The gap between the two, at each activity, is its float, and zero float marks the critical path.
What are the four dependency types?
Finish to start, where a task waits for another to finish, is the common one. Start to start links two beginnings. Finish to finish links two endings. Start to finish, the rare one, ties a successor's finish to a predecessor's start. Each connects a different end of the predecessor to the successor.
Can a network have more than one critical path?
Yes. Any chain of activities with zero float is critical, and a network can hold several such chains at once. There can also be a near-critical path carrying only a day or two of float that becomes critical the moment an estimate on it grows, which is why it pays to watch the low-float chains too.