Critical Path Method (CPM): The 6-Step Calculation, Examples, and a Live Calculator
The Critical Path Method gets cited more than it gets used. Most teams know it as "the longest sequence of tasks," draw a quick arrow diagram once, and move on. The actual value of CPM shows up later, when an activity slips and the project manager needs to know within a minute whether the slip will move the end date. CPM is the math that answers that question.
This guide covers CPM as it actually works in 2026. The 1957 origin story. The math behind earliest start, latest finish, and float. A worked example using a SaaS feature launch. The comparison to PERT, Gantt, and WBS, and an honest take on when CPM is overkill. Use the calculator below to compute your own critical path as you read.
Find your critical path
Add activities, durations, and what each one depends on. The widget runs the math.
Quick answer. The Critical Path Method (CPM) is a project scheduling technique that finds the longest dependency-respecting sequence of activities through a project network. Activities on the critical path have zero float, meaning any slip on them delays the whole project. CPM uses a forward pass (earliest start and finish) and a backward pass (latest start and finish) to compute the schedule and identify which activities have wiggle room.
What the Critical Path Method is
CPM is a deterministic scheduling technique. It takes a list of activities, their durations, and the dependency relationships between them. From those inputs, it computes the earliest and latest moments each activity can start and finish without delaying the project. The chain of activities with no slack is the critical path, and its total duration equals the project duration.
The output is more than a schedule. It is a structural diagnosis of the project. The critical path tells the project manager which activities deserve daily attention. Float tells them which activities can absorb a slip. Together they turn schedule risk from a vague worry into a managed quantity. Without the math, every delay feels equally serious; with it, only the critical-path delays really are.
Where CPM came from
The technique was developed in 1957 by Morgan R. Walker at DuPont and James E. Kelley at Remington Rand. They were trying to schedule plant maintenance shutdowns where the math of overlapping dependencies had outgrown what could be done by hand. CPM gave them a repeatable way to calculate which activities mattered most for total downtime.
"The advent of computers and the development of associated mathematical techniques gave rise to a number of new approaches to the management of large-scale projects. The Critical Path Method, originally introduced by James E. Kelley, Jr., of Remington Rand and Morgan R. Walker of Du Pont, has proven to be one of the most useful." - Levy, Thompson, and Wiest, "The ABCs of the Critical Path Method," Harvard Business Review, September 1963
The Navy was running a parallel effort. The Polaris missile program needed to schedule thousands of activities with novel durations no one had ever measured. Their answer was PERT, which uses three-point estimates instead of single values. CPM and PERT converged in practice, and the modern field treats them as variants of the same family.
CPM glossary
Six terms do most of the work in any CPM conversation. The notation looks intimidating in textbooks but reads cleanly once you have seen it twice.
| Term | What it means | Notation |
|---|---|---|
| Activity | A single piece of work in the project. Each activity has a duration and zero or more predecessor activities. | Letter or numeric ID (A, B, 1, 2) |
| Duration | How long the activity takes once it starts. Usually expressed in days, but can be hours, weeks, or any time unit. | d |
| Dependency | The relationship that says one activity cannot start until another finishes. The most common type is finish-to-start. | FS, SS, FF, SF |
| Earliest startES | The earliest moment the activity can start, given that all its predecessors must finish first. Comes from the forward pass. | ES |
| Earliest finishEF | Earliest start plus duration. The earliest the activity can finish. | EF = ES + d |
| Latest finishLF | The latest the activity can finish without delaying the project. Comes from the backward pass, working from the end. | LF |
| Latest startLS | Latest finish minus duration. The latest the activity can start without pushing the project end date. | LS = LF - d |
| Float (slack) | How much the activity can slip without delaying the project. Activities with zero float are on the critical path. | Float = LS - ES |
| Critical path | The longest sequence of dependent activities through the network. Total duration of the critical path equals the project duration. | Bold or red in diagrams |
| Network diagram | A visual of activities (nodes) connected by dependency arrows. Activity-on-Node (AON) is the standard format used today. | AON, ADM |
The four time values (ES, EF, LS, LF) for any single activity are usually drawn in the four corners of the activity node in a network diagram. Float sits in the middle. Critical-path activities are highlighted, often in red or with a thicker border.
How to find your critical path in 6 steps
The process is the same whether you do it on a whiteboard, in a spreadsheet, or with the calculator above. Six steps, walked here with the SaaS feature launch example used in the calculator preset.
- List every activity Pull the activity list from the Work Breakdown Structure. Each activity needs a short ID (A, B, C), a name, and an estimated duration. CPM is only as good as the activity list. If a real piece of work is missing here, the critical path will be wrong by exactly that piece of work. Example: A Spec doc (5d), B Backend API (10d), C Frontend UI (8d), D Launch (3d)
- Map the dependencies For each activity, write down what must finish first. Most dependencies are finish-to-start: B cannot start until A finishes. The dependency mapping is where most CPM errors originate. If two activities can actually run in parallel, do not chain them. False dependencies inflate the critical path. Example: A starts the project. B and C both need A (parallel: backend and frontend can build at the same time). D (Launch) needs both B and C to finish.
- Run the forward pass Walk the network from start to finish. For each activity, the Earliest Start (ES) is the maximum Earliest Finish (EF) of all its predecessors. The Earliest Finish equals ES plus duration. Activities with no predecessors start at ES = 0. The largest EF in the network is the project end date. Example: A: ES 0, EF 5. B: ES 5, EF 15. C: ES 5, EF 13. D: ES 15 (max of B and C), EF 18. Project ends at 18 days.
- Run the backward pass Now walk the network from finish back to start. The Latest Finish (LF) of the last activity equals the project end date. For every other activity, LF equals the minimum Latest Start (LS) of all its successors. LS equals LF minus duration. The backward pass tells you the latest each activity can run without delaying the project. Example: D: LF 18, LS 15. C: LF 15 (D's LS), LS 7. B: LF 15 (D's LS), LS 5. A: LF 5 (min of B's and C's LS), LS 0.
- Calculate float for each activity Float (also called slack) equals LS minus ES, or equivalently LF minus EF. Activities with float greater than zero have wiggle room. Activities with zero float have none. Float tells the project manager which tasks can slip without consequences and which ones cannot. It is the single most useful number CPM produces. Example: C has 2 days of float (LS 7 minus ES 5). A, B, and D all have zero float.
- Identify the critical path The critical path is the chain of activities with zero float. It is the longest dependency-respecting path through the network, and its length equals the project duration. Any delay on a critical path activity delays the whole project. Multiple critical paths can exist when several chains tie for the longest. Re-run the calculation whenever durations or dependencies change. Example: A → B → D is the critical path (all zero float, total 18 days). C is the only off-path activity. Pull C early or push it late, the project still ships in 18 days.
The math is mechanical once you have the activity list and dependencies. The intellectual work is in steps 1 and 2: getting the activities right, getting the dependencies honest. Most CPM errors trace back to a missing activity or a fake dependency.
Worked example: SaaS feature launch
Run the calculator at the top with the SaaS preset selected. The math produces the result below: a 4-activity project that finishes in 18 days, with a clear critical path and one activity carrying float.
Worked example: SaaS feature launch
4 activities, 18 days, critical path A → B → D
What the project manager learns from this. Frontend UI can slip up to 2 days without consequence. Backend API has zero room. If B slips by 1 day, the project ends a day later. If C slips by 1 day, nothing changes.
If C slips by 3 days, the critical path moves to A → C → D and total duration becomes 19 days. The math tells you when the path itself shifts, not just whether your favorite activity is late.
This is the operational value of CPM. Without it, every slip looks equally urgent. With it, the project manager can say "B slipped, this matters" or "C slipped, no action needed" within seconds of seeing the update. The critical path is a triage tool as much as a schedule.
CPM vs PERT vs Gantt vs WBS
Four scheduling and scope methods get conflated in most project management conversations. Each one answers a different question. Treating them as one bloated artifact is how teams end up with a 50-page PMBOK Word doc that nobody updates.
| Method | What it answers | Format | Best for |
|---|---|---|---|
| Work Breakdown Structure | What the deliverables areDecomposition, no time | Tree or numbered outline | Defining scope before scheduling anything |
| Critical Path Method | What sequence drives the scheduleTime and dependencies, deterministic durations | Network diagram with critical path highlighted | Projects with hard dependencies and many parallel tracks |
| PERT | What sequence drives the schedule under uncertaintyThree-point duration estimates instead of single values | Network diagram with weighted estimates | R&D, novel work, projects where durations are unknown |
| Gantt chart | When each task happens on a calendarVisual timeline, tracks progress against dates | Horizontal bars on a timeline | Communicating schedule to stakeholders, day-to-day execution |
The sequence in practice. The Work Breakdown Structure decomposes scope into deliverables and work packages. CPM (or PERT) computes which sequence drives the schedule. The Gantt chart visualizes the schedule on a calendar with the critical path highlighted. None of them replaces the others. Each one is the right tool for its specific job, and a project plan that uses all four covers different angles of the same underlying scope.
CPM in agile programs
Most CPM articles treat the method as waterfall-only. That framing is outdated. CPM does not survive at the user-story level inside a single sprint, where iteration speed matters more than dependency math. But it absolutely survives at the program level, where multiple agile teams have hard cross-team dependencies that span sprints.
The Scaled Agile Framework calls these dependencies the program board. The activities are not stories; they are epics, integration milestones, hardening sprints, and release events. The critical path runs through whichever epics genuinely block release. A release train with 8 teams, 60 epics in the program increment, and 3 hard external dependencies has a critical path. Identifying it is the same calculation as in waterfall, just at a different altitude.
"CPM is over a half century old, has been computerized for over 35 years, and has been the keystone of major capital projects throughout that time. Yet many of its features and capabilities are unknown or misunderstood by today's planning and scheduling community." - James M. Bedrick, PMP, "A Better Way to Schedule," Project Management Institute
The pattern we see at Rock. Cross-functional teams running quarterly programs use CPM-style dependency mapping for their 4 to 8 most important deliverables, even when the underlying execution is sprint-based. The calculator at the top of this article models exactly that scale. 4 activities, mixed parallel and sequential work, output that fits on one screen and gets re-run when something shifts.
Common CPM mistakes
Five patterns account for most of the failures we see. They are easy to spot in a draft network diagram if you know what to look for.
- Treating soft sequences as hard dependencies Two activities that "usually" happen in order are not the same as two activities that must happen in order. False finish-to-start chains inflate the critical path and make the project look longer than it actually is. Before drawing a dependency, ask whether the second activity literally cannot start until the first finishes. If the answer is "no, it just usually does," remove the link.
- Using single-point duration estimates CPM uses one number per activity, which makes the math clean but the schedule fragile. Real durations vary. The original method assumes deterministic estimates; PERT exists precisely to handle this with three-point estimates (optimistic, most likely, pessimistic). For projects with novel work or genuine uncertainty, plain CPM understates risk. Either pad estimates honestly or move to PERT.
- Ignoring resource constraints Plain CPM assumes infinite resources. The math says C and D can run in parallel, but if the same engineer does both, they cannot. The critical path on paper diverges from the executable schedule. Run a resource-leveling pass after the CPM calculation, or surface the conflict in the project plan and re-sequence accordingly.
- Building it once and never updating A CPM diagram from week one is a one-shot artifact. By month two, durations have shifted, dependencies have changed, and one activity that did not exist at kickoff is now blocking everything. The critical path can move during execution. Recompute at every phase boundary, every scope change, and any time an activity slips by more than its float.
- Confusing CPM with the Gantt chart CPM produces dependency math (which sequence drives the schedule). A Gantt chart visualizes when work happens on a calendar. They are not interchangeable, and a Gantt chart with no critical-path overlay misses the whole point of doing CPM in the first place. Always render the critical path as a distinct color or band on the Gantt, or the calculation has no operational impact.
The first three are structural (false dependencies, single-point estimates, ignored resource constraints). The last two are operational (one-shot artifact, no Gantt overlay). Both kinds matter, and a CPM diagram that fails on either side stops being load-bearing within a month.
When to skip CPM
CPM is not load-bearing for every project. Three contexts where skipping it is the right call.
Projects with fewer than ~15 activities. If the entire project fits on a sticky-note timeline, CPM is overhead. The dependencies are obvious by inspection, the critical path is whatever you eyeball, and the math adds nothing the project manager could not already see. Run a simple ordered task list with target dates instead.
Projects with no hard dependencies. If activities can mostly run in parallel and the team is capacity-bound rather than dependency-bound, CPM produces a near-flat critical path that maps to whatever activity has the longest duration. The diagram looks impressive but tells the team nothing they did not already know. Resource leveling is the more useful tool for this shape of project.
Highly iterative work. Discovery engagements, R&D phases, and product work where the activity list itself is the output of the project. CPM built before you know what the activities are is fiction. Either run the discovery first and apply CPM to the implementation, or accept that an agile backlog is the better fit.
Most projects do not fall into these three buckets. For mid-size to large projects with hard dependencies, fixed launch dates, and parallel workstreams, CPM is worth the hour it takes to set up. Recomputing when something shifts takes about 5 minutes.
What we recommend
Most teams skip CPM because the textbook treatment makes it look academic. It is not. It is a 1-hour scheduling exercise that prevents two patterns of pain. First, the team treats every slip as equally urgent, exhausting itself on activities with float. Second, the team underreacts to a critical-path slip because nobody flagged it as critical until the project missed its end date.
Build the network in whatever tool makes the math visible. The calculator above runs the forward and backward pass instantly and works for projects up to about 30 activities. Spreadsheets work for the same range with the right formulas. Specialized tools (MS Project, Smartsheet, GanttPRO, Primavera) are appropriate above that scale.
The tool matters less than two checks: the activity list comes from a real Work Breakdown Structure, and dependencies are honest finish-to-start relationships, not narrative sequences.
Then move execution to a workspace tool that keeps the activities, owners, and status next to the team conversation. The pattern we see at Rock is consistent. Cross-functional teams compute the critical path in a calculator or spreadsheet, then map each activity to a task in Rock with the predecessor relationships visible.
The team chat sits next to the tasks. When an activity slips, the conversation, the dependency, and the status update happen in the same space, not across three tools. That is what turns CPM from a kickoff diagram into a tool that gets re-used during execution.
"The hardest part of using CPM is not the math. It is keeping the dependency list honest and updating it when things change. Half the value comes from the discipline of asking which activities really cannot start until others finish." - Nicolaas Spijker, Marketing Expert
Two failure modes to watch. First, the team builds a beautiful network diagram and never recomputes. By month two, the critical path has moved and the team is still optimizing the wrong activities. Recompute at every phase boundary.
Second, the team computes the critical path but does not surface it to the daily conversation. Mark critical-path activities visibly in the project workspace, label them in standups, color them in the Gantt overlay. CPM is only as useful as its visibility.
FAQ
What are the 6 steps of the Critical Path Method?
List every activity, map dependencies, run the forward pass to find earliest start and earliest finish, run the backward pass to find latest start and latest finish, calculate float for each activity, then identify the chain of zero-float activities. The chain is the critical path. The total of its durations equals the project duration.
What is float in CPM?
Float (also called slack) is how much an activity can slip without delaying the project. It equals Latest Start minus Earliest Start. Activities with zero float are on the critical path. Activities with positive float have wiggle room. Float is the most operationally useful number CPM produces, because it tells the project manager which slips are recoverable and which ones move the end date.
What is the difference between CPM and PERT?
CPM uses single-point duration estimates and assumes deterministic activity times. PERT uses three-point estimates (optimistic, most likely, pessimistic) and produces a probabilistic project duration. CPM was developed at DuPont in 1957 for industrial maintenance with well-known durations. PERT was developed at the US Navy in the same era for the Polaris missile program where many activities were novel. For most modern projects with mixed certainty, CPM with padded estimates is the practical default.
Can CPM be done in Excel?
Yes, for projects under about 30 activities. Set up columns for ID, name, duration, predecessors, ES, EF, LS, LF, and float. Use formulas to compute each pass. Highlight zero-float rows. Beyond 30 activities the network gets hard to maintain in a flat spreadsheet, and a dedicated tool (or the calculator at the top of this page) is faster.
Where did the Critical Path Method come from?
CPM was developed in 1957 by Morgan R. Walker at DuPont and James E. Kelley at Remington Rand. They needed to schedule plant maintenance shutdowns where the math of overlapping dependencies was getting too complex to do by hand. The 1963 Harvard Business Review article "The ABCs of the Critical Path Method" by Levy, Thompson, and Wiest popularized it for general project management.
Does CPM still apply in agile projects?
Partly. Inside a single sprint, CPM is overkill. But at the program level, where multiple agile teams have hard cross-team dependencies (release trains, hardening sprints, release dates tied to events), CPM-style dependency mapping is still useful. The critical path runs through the few activities that genuinely block release, not through every backlog item.
The right project tool keeps the schedule and the conversation in the same place. Rock turns each activity into a task with dependencies, owners, and chat next to it. One flat price, unlimited users, clients included. Get started for free.
