What is the Critical Path Method (CPM)?

CPM models a project as a directed network of tasks (activities) connected by dependencies. Each task has a duration, and each dependency says that one task constrains when another can start or finish. From this network and the task durations, CPM computes the start and finish dates for every task and identifies the critical path.

Crucially, classic CPM assumes unlimited resources — it cares only about the logic of the network and the durations, not whether the same engineer is needed on two tasks at once. That assumption keeps the math clean and is the reason the critical path can differ from the resource-feasible critical chain used in Critical Chain Project Management.

The forward pass works left to right through the network to compute the earliest each task can happen. The early start (ES) of a task is the latest early finish of all its predecessors; its early finish (EF) is its early start plus its duration. Working forward through every task, the largest early finish in the network is the earliest the project can complete.

Intuitively, a task cannot begin until everything it depends on is done, so each task inherits the latest of its incoming finish dates. The forward pass establishes the optimistic, as-soon-as-possible timeline for the entire plan.

The backward pass works right to left from the project finish to compute the latest each task can happen without delaying the project. The late finish (LF) of a task is the earliest late start of all its successors; its late start (LS) is its late finish minus its duration. The backward pass establishes the as-late-as-possible timeline.

Together, the forward and backward passes give every task four dates — ES, EF, LS, LF — and the gap between the earliest and latest dates is what reveals how much each task can slip.

Total float is the amount a task can slip without delaying the project finish: late start minus early start (equivalently, late finish minus early finish). Free float is the narrower measure — how much a task can slip without delaying any of its immediate successors. A task can have total float but zero free float, meaning it has room overall but moving it would still push the next task.

The critical path is the chain of tasks with zero total float. Those tasks have no room to move, so the project finish is only as safe as the most fragile task on that chain. Everything else has slack — but only as much as its float allows.

A path with one day of float is not the critical path, but it is almost certainly going to matter. Near-critical paths — chains with small float — frequently become critical the moment a single task slips, and they are invisible if you watch only the zero-float path. On uncertain work, a path that is technically off the critical path can drive the finish date more often than the named critical path does.

This is one of the clearest reasons deterministic CPM under-warns: it draws a hard line at zero float, when in reality risk lives in a band of near-critical work. A good schedule-risk view tracks how often each path actually becomes critical, not just which one is critical in the single-point plan.

CPM supports four relationship types between a predecessor and a successor. Finish-to-Start (FS) is by far the most common: the successor starts after the predecessor finishes. Start-to-Start (SS) ties the starts together; Finish-to-Finish (FF) ties the finishes; and Start-to-Finish (SF) — rare — ties the predecessor's start to the successor's finish.

Lag adds a deliberate delay to a relationship — for example, FS+5d means a successor starts five days after its predecessor finishes, useful for cure times, review windows, or shipping. Negative lag (lead) lets a successor begin before its predecessor fully completes. Used carefully, these relationships model real overlap; overused, they hide logic and make a schedule fragile.

CPM is necessary: you cannot manage a program without the dependency logic, the float, and the critical path it produces. But it is not sufficient, because it treats every duration as a fixed number. A 30-day task is rarely exactly 30 days — it has a distribution. CPM collapses that distribution to a single point and then reports a single finish date with false precision.

The consequences are predictable. The single-point CPM date is almost always optimistic, because it ignores the variance that compounds along a chain and the way risk migrates between near-critical paths. A board deck built on a deterministic CPM date carries a number nobody actually computed the probability of. To know your real P50, P80, or P90 finish date, you have to run the network many times with uncertain durations — which is Monte Carlo schedule risk analysis layered on top of CPM, not a replacement for it.

CritPath AI starts with a full CPM engine — all four dependency types, lag and lead, total and free float, and explicit near-critical detection — so the deterministic backbone is correct and auditable. It then layers the techniques CPM alone cannot provide: Monte Carlo simulation (PERT-Beta durations, risk-event injection, a criticality index showing how often each task lands on the critical path, tornado sensitivity, and P50/P80/P90 dates), Critical Chain buffers and Drum-Buffer-Rope, decision gates with retroactive rescheduling, and an AI copilot that reasons over your actual dependency graph rather than a generic chat overlay.

The result is a schedule that keeps the rigor of CPM but stops lying about certainty. It is $10 per user per month, with AI usage billed separately by metered usage — a fraction of a single legacy desktop schedule-risk seat, delivered as a modern web app.