The Critical Path Method (CPM) identifies the longest sequence of dependent tasks in your project — the path that determines your minimum project duration. Any delay on a critical path task delays the entire project. Everything else has float.

Critical Path Method Explained

CPM was developed in the late 1950s by DuPont and Remington Rand for managing plant maintenance shutdowns. Sixty years later, it remains one of the most practical scheduling techniques available, and you do not need specialized software to use it.

Core Concepts

Activity. A task with a defined duration. “Design database schema — 3 days” is an activity.

Dependency. A relationship between activities. “Database schema must be complete before API development starts” is a finish-to-start dependency. There are four types: finish-to-start (most common), start-to-start, finish-to-finish, and start-to-finish (rare).

Forward pass. Calculating the earliest start and earliest finish for each activity by working through the network from beginning to end.

Backward pass. Calculating the latest start and latest finish for each activity by working backward from the project deadline.

Float (slack). The difference between the latest and earliest start times. Activities with zero float are on the critical path — they cannot slip without delaying the project.

Building a CPM Network: Step by Step

Step 1: List All Activities and Durations

Start with your work breakdown structure. For each work package, estimate the duration. Use consistent units — days is standard.

ID	Activity	Duration (days)	Predecessors
A	Requirements gathering	5	—
B	Database design	3	A
C	UI wireframes	4	A
D	API development	8	B
E	Frontend development	6	C
F	Integration testing	4	D, E
G	User acceptance testing	3	F

Step 2: Draw the Network Diagram

Create a node for each activity. Draw arrows showing dependencies. This gives you a visual map of the project flow. Tools like Microsoft Project, Smartsheet, or even a whiteboard work for this.

Step 3: Forward Pass

Starting from the first activity, calculate the earliest start (ES) and earliest finish (EF) for each task.

Activity A: ES=0, EF=5
Activity B: ES=5, EF=8
Activity C: ES=5, EF=9
Activity D: ES=8, EF=16
Activity E: ES=9, EF=15
Activity F: ES=16, EF=20 (must wait for both D and E; D finishes later at day 16)
Activity G: ES=20, EF=23

The project takes a minimum of 23 days.

Step 4: Backward Pass

Starting from the end, calculate the latest finish (LF) and latest start (LS) for each task without delaying the project.

Activity G: LF=23, LS=20
Activity F: LF=20, LS=16
Activity D: LF=16, LS=8
Activity E: LF=16, LS=10
Activity C: LF=10, LS=6
Activity B: LF=8, LS=5
Activity A: LF=5, LS=0

Step 5: Calculate Float

Float = LS - ES (or LF - EF).

A: 0-0 = 0 (critical)
B: 5-5 = 0 (critical)
C: 6-5 = 1 day float
D: 8-8 = 0 (critical)
E: 10-9 = 1 day float
F: 16-16 = 0 (critical)
G: 20-20 = 0 (critical)

The critical path is A → B → D → F → G (23 days). Activities C and E each have 1 day of float — they can slip by one day without affecting the project deadline.

Using CPM in Practice

Crashing the Schedule

When the calculated duration exceeds the deadline, you need to compress the critical path. “Crashing” means adding resources to critical path activities to reduce their duration. This always costs money, so focus on the cheapest activities to crash first.

If adding a second developer to Activity D (API development) reduces it from 8 to 5 days, the critical path drops from 23 to 20 days. But check whether this creates a new critical path — compressing D might make the C → E path critical instead.

Fast-Tracking

Running activities in parallel that were originally sequential. If you can start API development before the database design is fully complete — perhaps by defining the schema for the first module and beginning API work on that module — you overlap B and D partially. Fast-tracking introduces risk because parallel activities may need rework if the predecessor output changes.

Resource Leveling

CPM assumes unlimited resources. Reality disagrees. If activities B and C both need the same senior developer and overlap in time, one must shift. Resource leveling adjusts the schedule to respect actual resource availability, which may extend the project beyond the CPM minimum.

CPM and Agile: Compatible or Conflicting?

CPM works best with predictable, well-defined projects — exactly where Waterfall shines. But Agile teams use CPM concepts informally. Managing project dependencies across teams, identifying which features block others, and sequencing sprint goals to minimize idle time all draw on critical path thinking.

For Agile release planning, a lightweight version of CPM helps identify which epics must complete before others and where the real bottlenecks in a multi-team program sit.

Tool Support

Microsoft Project and Smartsheet calculate the critical path automatically from task dependencies. Monday.com and ClickUp support dependency tracking but may require add-ons for true CPM analysis. For simple projects, a spreadsheet with the formulas above works fine.

Gantt charts are the standard visualization for CPM output — they show task durations, dependencies, and float at a glance. Most PM tools generate Gantt views from dependency data.

Common Mistakes

Skipping the dependency analysis and estimating the project end date by summing durations. CPM accounts for parallelism — tasks that can run simultaneously reduce total duration.

Ignoring float. Teams that treat every task as critical create false urgency. Communicating which tasks have float helps the team make informed tradeoff decisions when priorities compete.

Not updating the network as the project progresses. The critical path can shift as actual durations differ from estimates. Re-run the analysis at major milestones to keep your focus on the right tasks.