Critical path method (CPM)

Why use CPM

1. Plan realistic timelines: you can see how long the project will take in the worst-case scenario.
2. Set priorities: critical tasks get the most attention and resources.
3. Manage risks: you know the weak spots and can plan safeguards in advance, such as allocating resources or agreeing buffer time.

How to find the critical path in a project

Step 1. List the tasks

Break the project down into specific, measurable tasks. Example for a web application:

• Task A: architecture design (3 days);
• Task B: back-end API development (5 days);
• Task C: front-end development (7 days);
• Task D: database setup (4 days);
• Task E: testing and debugging (2 days);
• Task F: production deployment (1 day).

Step 2. Identify dependencies

Dependency types:

• Finish-to-start (the most common): the next task starts once the previous one is finished;
• Start-to-start: tasks start at the same time;
• Finish-to-finish: tasks finish at the same time.

Dependencies in the example: B depends on A, C on B, E on D, F on C/D/E. Tasks C and D run in parallel.

Step 3. Build a network diagram

Visualize the sequence of tasks along with their durations. In our example, task A leads to task B, from which two parallel paths branch out: one through task C and one through tasks D and E. All paths converge on the final task F.

Step 4. Estimate durations

Determine how long each task will take. For accurate estimates, use:

• expert judgment: ask the specialists who will do the work;
• historical data: look at how long similar tasks took on past projects;
• industry benchmarks: use standard rates for typical work;
• three-point estimation: calculate a weighted average of three scenarios using the formula (Optimistic + 4 × Most likely + Pessimistic) / 6.

Step 5. Calculate the critical path

The forward pass calculates the earliest possible dates for each task, moving from the start of the project to the end.

The backward pass calculates the latest allowable dates for each task, moving from the end of the project back to the start.

Tasks with zero float (A, B, C, F) form the critical path: A → B → C → F, with a duration of 16 days. Tasks D and E have 1 day of float. 

Forward pass: calculating early dates

Move from the start of the project to the end. For each task, determine the earliest start (ES) and earliest finish (EF). Formula: EF = ES + task duration.

• task A: starts at zero and finishes after 3 days (ES=0, EF=3);
• task B: starts after A and finishes after 5 days (ES=3, EF=8);
• task C: starts after B and finishes after 7 days (ES=8, EF=15);
• task D: starts after B in parallel with C and finishes after 4 days (ES=8, EF=12);
• task E: starts after D and finishes after 2 days (ES=12, EF=14);
• task F: starts once all preceding tasks are complete, taking the maximum of 15 and 14 (ES=15, EF=16).

Backward pass: calculating late dates

Move from the end of the project back to the start. For each task, determine the latest finish (LF) and latest start (LS) that won't push back the overall deadline. 

Formula: LS = LF - task duration.

• task F: must finish on day 16 and start no later than day 15 (LF=16, LS=15);
• task C: must finish by the start of F and start no later than day 8 (LF=15, LS=8);
• task E: must finish by the start of F and start no later than day 13 (LF=15, LS=13);
• task D: must finish by the start of E and start no later than day 9 (LF=13, LS=9);
• task B: must finish by the start of C and start no later than day 3 (LF=8, LS=3);
• task A: must finish by the start of B and start no later than day 0 (LF=3, LS=0).

Finding the critical path

Float = LS - ES. Tasks with zero float cannot be delayed.

• tasks A, B, C and F have 0 days of float: this is the critical path;
• tasks D and E have 1 day of float: they can slip slightly.

Critical path: A → B → C → F, with a total duration of 16 days. Any delay to these tasks will push back the entire project.

Critical path calculation example

Tasks:

• A: requirements analysis (5 days)
• B: architecture design (7 days)
• C: test environment setup (3 days)
• D: service catalog (10 days)
• E: Active Directory integration (4 days)
• F: portal build (8 days)
• G: testing (6 days)
• H: training (5 days)
• I: go-live (2 days)

Dependencies:

B follows A; C and D follow B; E follows C; F follows D; G follows E and F; H follows G; I follows H.

Calculation results:

Critical path: A → B → D → F → G → H → I = 43 days.

Practical takeaways:

• assign your strongest specialists to critical tasks D and F;
• add a 10–15% buffer to estimates for critical tasks;
• tasks C and E have 11 days of float, so their resources can be shifted to D and F;
• break the long task D into subtasks for better control.

How to use the critical path method in practice

The critical path method shows which tasks directly affect the project completion date. This lets you manage time and resources precisely, focusing on what matters most.

1. Compress the schedule

• fast-tracking: running work in parallel, for example starting to test finished modules before all development is complete. The risk: work may have to be redone if problems are found;
• crashing: adding resources to critical tasks. Keep in mind that not every task can be sped up by adding more people.

2. Manage resources

• resource smoothing: redistributing work without changing the critical path. An overloaded specialist first completes the critical task and then takes on a non-critical task that has float;
• resource leveling: adjusting the schedule, including the critical path, to even out workloads. Use it with care, as it extends the project duration.

3. Manage risks

• create a risk register for critical tasks;
• add time buffers for risky work;
• prepare a response plan: where you will find extra resources and what can be postponed.

4. Monitor progress

• recalculate the critical path weekly;
• make it visible to the team (critical tasks in red, non-critical in green);
• apply the 10% rule: if a critical task is delayed by more than 10%, notify the project manager immediately.

5. Communicate with the customer

• show the critical path diagram at kick-off and explain why the timeline is what it is;
• warn that new requirements affecting critical tasks will shift the whole project;
• report weekly: path status (green/amber/red), completed tasks and risks.

6. Avoid common mistakes

• ignoring non-critical tasks: they can become critical if delayed;
• over-detailed breakdown: 1–10 days per task is optimal;
• missed dependencies: identify all links, including hidden ones (shared resources, approvals);
• static planning: recalculate regularly;
• pressure without analysis: not every task speeds up with more resources.

CPM vs PERT vs Gantt chart

When to use which

CPM: construction, ITSM/CRM/ERP implementations, manufacturing, projects with late-delivery penalties.

PERT: new product development, research, early estimates for complex projects, high-risk work.

Gantt: customer presentations, progress tracking, resource allocation, simple projects.

Combining methods

PERT → CPM → Gantt is the classic sequence for complex projects:

1. PERT for estimating under uncertainty;
2. CPM for calculating the critical path;
3. Gantt for visualization and control.

CPM + Gantt works for predictable projects: you calculate the critical path and highlight it in red on the Gantt chart.

Software and tools

The critical path used to be calculated by hand, with diagrams drawn on paper and lengthy calculations. Today's software automates the calculations and lets you manage the critical path in real time.

SimpleOne SDLC: an application for developing software products and solutions using Agile methodologies

A development management system for software products and solutions built on Agile methodologies. Part of the SimpleOne enterprise service management ecosystem.

Capabilities for working with the critical path:

• task dependency management: visualizing links between work items to understand the order of execution;
• Kanban and Scrum boards: flexible task management at different project stages;

• resource planning: allocating the team based on workload and priorities;
• analytics dashboards: tracking lead times, time in status and team velocity;

• backlog management: controlling priorities and planning iterations;
• delivery reports: burndown, cumulative flow diagram (CFD), cycle time histogram;
• version control integration: a GitLab connection to track code changes.

Platform advantages:

• flexible customization: low-code/no-code tools let you tailor the system to your processes without programming;
• a single platform: no need to integrate disparate systems, everything works in one space;
• cloud or on-premise: choose the deployment option that suits your infrastructure;
• data migration: transfer of projects, tasks and users from other systems.