Critical Path Method: Finding the Chain That Can't Slip

A project is a graph, not a list

The Critical Path Method, developed independently at DuPont and Remington Rand in the late 1950s, models a project as a directed acyclic graph (DAG): each task is a node with a duration, and an edge from task A to task B means B cannot start until A finishes. A project schedule is not a sequence but a web of these dependencies - some tasks can run in parallel, others must wait, and the finish date is set by whichever chain of dependent tasks takes the longest to complete end to end.

The forward pass: how early can each task start?

Sweeping through the DAG in topological order, each task's earliest start (ES) is the latest of its predecessors' earliest finish times, and its earliest finish (EF) is simply ES plus its own duration. This forward pass propagates the fastest-possible schedule through the whole network and tells you the earliest date the project can possibly finish - the EF of the final task.

The backward pass: how late can each task start?

Now sweep backward from the project's fixed finish date. Each task's latest finish (LF) is the earliest of its successors' latest start times, and its latest start (LS) is LF minus its duration. This pass answers a different question: how far can each task's start slip before it starts eating into the overall deadline?

forward pass (topological order):
  ES(task) = max( EF(pred) for pred in predecessors ), 0 if none
  EF(task) = ES(task) + duration(task)

backward pass (reverse topological order):
  LF(task) = min( LS(succ) for succ in successors ), projectFinish if none
  LS(task) = LF(task) − duration(task)

slack(task) = LS(task) − ES(task)     // = LF(task) − EF(task)
critical path = every task with slack(task) == 0

Slack, and the path that cannot move

Subtracting ES from LS gives each task's slack (also called float): how many days it can be delayed without pushing back the project's finish date. Tasks with positive slack have breathing room - a two-day slack task can start two days late and the project still finishes on time. Tasks with zero slack have none: any delay there is a delay to the whole project. Chained together, the zero-slack tasks form the critical path - by construction the single longest route through the dependency graph, and therefore the shortest possible time the project can take. A project can have more than one critical path if two or more chains tie for the longest duration.

PERT: turning one duration into a probability

CPM assumes each task has a single, known duration, which is rarely true in practice. The Program Evaluation and Review Technique (PERT), developed for the US Navy's Polaris missile programme around the same time, instead asks for three estimates per task - optimistic (o), most likely (m) and pessimistic (p) - and combines them using a beta-distribution approximation into an expected duration and a variance:

expected duration:  te = (o + 4m + p) / 6
variance:           v  = ((p − o) / 6)²

project variance ≈ sum of variances of tasks on the critical path
P(finish ≤ deadline) ≈ Φ( (deadline − Σte) / √(Σv) )   // normal approximation

Summing the expected durations and variances along the critical path, then applying the normal approximation implied by the central limit theorem, turns a single deterministic schedule into an estimate of the probability that the whole project finishes by a target deadline - a genuinely useful answer to "how confident are we in this date" rather than a single optimistic number.

Frequently asked questions

Try it live

Everything above runs in your browser — open Critical Path Method and change the parameters while it is running. Nothing is installed, nothing is uploaded, the whole model lives in one tab.