Critical Path Method: How to Calculate What Really Sets the Deadline

Two weeks before launch, the project is behind. The documentation team works through the weekend and finishes two days early. On Monday, the final date hasn’t moved. The delay was in another activity.

In a project with dependencies, not every task weighs the same on the deadline. Some can slip with no effect, and others move the date on their first day of delay. The critical path method tells you which is which, with simple math.

What the critical path method is#

The Critical Path Method, or CPM, identifies the sequence of dependent activities that determines a project’s minimum calculated duration, for a given set of tasks, durations and dependencies.

The method was developed in the late 1950s by Morgan Walker of DuPont and James Kelley of Remington Rand (Kelley & Walker, 1959). Around the same time, the US Navy was creating PERT for the Polaris missile program (Malcolm et al., 1959). The traditional history treats them as independent inventions, but it’s disputed: Smith, Sharma & Baecher (2020) argue that CPM was probably derived from PERT, and that the two are essentially the same tool.

From the start, the model included costs, as well as sequence and duration (Kelley, 1961). That’s what lets you ask how much it costs to bring the date forward, as we’ll see.

When to use it and when to avoid it#

How to apply it#

Worked example: launching a product#

A company is preparing a product launch, with six activities. The last column shows what must finish first:

There are two paths from start to finish:

• A, B, D, F: 3 + 4 + 2 + 2 = 11 days.
• A, C, E, F: 3 + 2 + 3 + 2 = 10 days.

The longest one rules. The project takes 11 days, and the critical path is A, B, D, F. In a small network, adding up the paths does the job. In a real network, with dozens of activities, you use the forward and backward passes.

Forward and backward passes#

We’ll count from day 0, so an activity with a start of 3 begins when the third day ends. We’ll use four dates:

• ES and EF: early start and early finish.
• LS and LF: late start and late finish.

In the forward pass, from left to right, each activity starts when its last predecessor finishes. F depends on D and E, which finish on days 9 and 8, so F can only start on day 9.

In the backward pass, from right to left, each activity must finish before its tightest successor starts. The deadline is 11, so F must start by day 9. That means E must finish by day 9, and can start as late as day 6.

The difference between the two dates is the total float:

Activities with zero float form the critical path. C and E have 1 day of float.

Total float and free float#

There’s a catch in that table. C and E have 1 day of float, but not 1 day each: float is shared along the path. If C slips 1 day, E starts on day 6 and loses its own.

That’s why another concept exists. Total float measures how much you can slip without moving the final deadline. Free float measures how much you can slip without affecting the start of the next activity. Here, C has a total float of 1 and a free float of 0. E has 1 of each. In practice, a delay in C passes the problem to E’s team, even without changing the final date.

The network changes during the project#

The critical path isn’t fixed. If B slips 1 day, the deadline moves to 12 days. If C slips 1 day, the final date doesn’t change, but A, C, E, F also reaches 11 days, and the project now has two critical paths. If C slips 2 days, the deadline moves to 12, and that’s now the critical path, not the original one.

So the network must be recalculated with actual durations as the project moves. A critical path set at the start and never reviewed can point the team’s attention at the wrong place.

How to shorten the schedule#

Shortening an activity usually costs money, through overtime or more people. This is called crashing. Suppose you can do the following:

C is the cheapest activity to crash, but it’s off the critical path. Spending there brings nothing forward. The cut starts with the cheapest critical activity: B. Cutting B by 1 day brings the critical path down to 10, and the other path is also at 10.

Now there are two critical paths. Any further cut must hit both. The cheapest way is F, which belongs to both. Calculating every combination, the lowest cost for each target is:

Each day costs more than the last: 2,000, 2,500, 3,000 and 4,500. Below 7 days, there’s nothing left to crash. The decision becomes a business one: if each day gained is worth 3,500, it makes sense to stop at 8 days, because the last cut would cost 4,500.

Another way is to run activities in parallel, such as starting security validation before integration ends. This is called fast-tracking. It doesn’t cost more per day, but it raises the risk of rework.

These cuts have a side effect: less float. With two critical paths, a delay anywhere in the network affects the date.

What resources change#

Classic CPM considers only logical dependencies. It doesn’t know who does what. Suppose B and E depend on the same specialist, who can only do one thing at a time. By the math, B runs from day 3 to 7, and E from day 5 to 8. The two overlap.

If E waits for B to finish, E runs from day 7 to 10, and F finishes on day 12. The deadline grew by a day with no task running late. A new sequence, A, B, E, F, now rules. This is called the resource-critical path, and techniques such as resource leveling and critical chain exist to deal with it (Wikipedia).

What uncertainty changes#

The 11 days are exact only because the durations are fixed. Estimates aren’t. To see the effect, we simulated the same network 200,000 times for this article. Each duration varied from 20% below to 50% above the estimate, with the estimate as the most likely value. That asymmetry is an assumption, but it’s common for tasks to run late more than early.

Two lessons. The calculated date is an optimistic value, not a forecast, and promising 11 days would mean accepting a more than 90% chance of delay in this simulation. And the path with float sometimes becomes the critical one. A near-critical path deserves watching, and 1 day of float is no guarantee of safety.

This problem is old. Since the first work on networks, it’s been pointed out that basing duration on the path with the largest sum gives optimistic results (PMI). When several paths meet at the end, one of them running late is enough to delay the project.

Common mistakes#

• Treating float as free time. Float is protection, and it’s shared along the path.
• Hiding padding in durations. If everyone builds safety into their own estimate, the network stops showing where the risk is.
• Creating dependencies that are just preferences. “We always do it in this order” can hide activities that could run in parallel.
• Speeding up what’s visible. The noisiest activity isn’t always the critical one.

The calculation in Python#

This script reproduces the table. Activities must be in an order that respects the dependencies:

activities = {
    "A": (3, []),
    "B": (4, ["A"]),
    "C": (2, ["A"]),
    "D": (2, ["B"]),
    "E": (3, ["C"]),
    "F": (2, ["D", "E"]),
}

# Forward pass: each activity finishes after its last predecessor
early_finish = {}
for name, (duration, before) in activities.items():
    start = max((early_finish[b] for b in before), default=0)
    early_finish[name] = start + duration

deadline = max(early_finish.values())

# Backward pass: each predecessor finishes before its tightest successor
late_finish = {name: deadline for name in activities}
for name in reversed(list(activities)):
    duration, before = activities[name]
    for b in before:
        late_finish[b] = min(late_finish[b], late_finish[name] - duration)

for name in activities:
    float_days = late_finish[name] - early_finish[name]
    print(name, "float:", float_days, "critical" if float_days == 0 else "")

print("Deadline:", deadline)

How to use an LLM#

An LLM is useful for suggesting forgotten activities, questioning dependencies and explaining the result. For the math, use a spreadsheet, a script or a project tool: models can get a sum wrong silently. If durations are missing, it shouldn’t invent a schedule.

Build the dependency network of a project to apply CPM.
Goal and final milestone: [describe].
Activities, durations and dependencies: [table or list].
Working calendar, holidays and resource constraints: [describe].

Check for impossible dependencies or cycles. Calculate early and late
start and finish, total float and critical path(s), showing assumptions
and math. Propose ways to shorten the schedule and their trade-offs.
If durations are missing, don't fabricate a precise schedule: deliver
the structure and request the estimates needed.

Expected output: the project network, critical path and a dependency-based schedule.

Before trusting the answer:

• Redo the math. Run the numbers in a script or a project tool.
• Review dependencies with those doing the work. The model infers links that may not exist, and forgets others.
• Look for shared resources. Ask which activities depend on the same person or environment.
• Sanitize the context. Launch dates, vendors and people’s names may be confidential.

Combine it with other frameworks#

• OODA loop: CPM plans a known network; OODA adapts decisions when the environment changes.
• MECE principle: helps split the work without overlaps or gaps.
• Pre-mortem analysis: reveals what could delay critical activities.
• Cost-benefit analysis: compares the cost of bringing the date forward with the value of delivering earlier.
• Eisenhower Matrix: organizes an individual agenda; CPM shows what matters for the project’s deadline.

References#

1. Kelley, J. E. (1961). Critical-Path Planning and Scheduling: Mathematical Basis. Operations Research, 9(3), 296–320. DOI
2. Kelley, J. E. & Walker, M. R. (1959). Critical-path planning and scheduling. Eastern Joint Computer Conference, 160–173. DOI
3. Malcolm, D. G., Roseboom, J. H., Clark, C. E. & Fazar, W. (1959). Application of a Technique for Research and Development Program Evaluation. Operations Research, 7(5), 646–669. DOI
4. Project Management Institute. Project network models: past, present and future. Link
5. Smith, C. C., Sharma, V. & Baecher, G. B. (2020). PERT, CPM and the Tangled History of Network Scheduling. The Professional Constructor, 45(2). Link
6. Wikipedia. Critical path method. Link