---
title: "Scheduling and the critical path | Optimize All Academy"
description: "From WBS to schedule A schedule turns work packages into activities with durations, logic links and resources. The standard technique is the critical…"
url: https://optimizeall.com/learn/project-controls-with-ai/scheduling-and-critical-path
updated: 2026-10-05
---

Project Controls in the AI Era · Foundations of project controls · lesson 3 of 22 · 16 min

# Scheduling and the critical path

## From WBS to schedule

A schedule turns work packages into **activities** with durations, logic links and resources. The standard technique is the **critical path method (CPM)**. Its output is the earliest possible finish date for the project and the chain of activities that determines it.

## The building blocks

- **Activity:** a unit of work with a duration (e.g., "Install ductwork Level 2 – 10 days").
- **Logic (dependencies):** mostly finish-to-start (FS): B cannot start until A finishes. Start-to-start (SS) and finish-to-finish (FF) are also used; start-to-finish (SF) is rare.
- **Lags and leads:** delays or overlaps on a link. Use sparingly and document why.
- **Constraints:** imposed dates ("start no earlier than"). Hard constraints override logic and can hide real delays, so keep them minimal.
- **Float (slack):** how much an activity can slip without delaying the project finish (**total float**) or its successor (**free float**).

## The forward and backward pass

1. **Forward pass:** compute the Early Start (ES) and Early Finish (EF) of each activity from the project start. EF = ES + duration. An activity's ES is the latest EF of its predecessors.
2. **Backward pass:** from the project finish, compute Late Finish (LF) and Late Start (LS). LS = LF − duration. An activity's LF is the earliest LS of its successors.
3. **Float:** Total float = LS − ES (or LF − EF).
4. **Critical path:** the longest path through the network; activities on it typically have zero total float (in a schedule without imposed constraints).

## Worked example

*Illustrative.* A small solar installation for a factory near Lahore. Durations in days; all links finish-to-start.

| Activity | Duration | Predecessors |
|---|---|---|
| A Site survey | 3 | – |
| B Structural design | 5 | A |
| C Procure panels | 10 | A |
| D Install mounting | 4 | B |
| E Install panels | 6 | C, D |
| F Grid connection approval | 8 | B |
| G Commission | 2 | E, F |

Forward pass (day numbers as elapsed days):

| Act | ES | EF |
|---|---|---|
| A | 0 | 3 |
| B | 3 | 8 |
| C | 3 | 13 |
| D | 8 | 12 |
| E | max(13, 12) = 13 | 19 |
| F | 8 | 16 |
| G | max(19, 16) = 19 | 21 |

Project duration = 21 days. Backward pass from 21: G LF 21, LS 19. E LF 19, LS 13. F LF 19, LS 11. D LF 13, LS 9. C LF 13, LS 3. B LF = min(LS of D = 9, LS of F = 11) = 9, LS 4. A LF = min(LS of B = 4, LS of C = 3) = 3, LS 0.

Total float: A 0, B 1, C 0, D 1, E 0, F 3, G 0. **Critical path: A → C → E → G (21 days).** The team had been focusing on design and grid approval, but the real driver is panel procurement. A two-day procurement delay delays the whole project by two days; a two-day design delay only consumes one day of float and then delays the finish by one.

## Schedule quality checks

Before baselining, run a quality check. Commonly used checks (inspired by widely used schedule assessment practices) include:

| Check | What to look for |
|---|---|
| Missing logic | Every activity (except start and finish) has a predecessor and a successor |
| Leads / negative lags | Avoid; they obscure logic |
| Excessive lags | Replace long lags with real activities (e.g., "Concrete curing") |
| Hard constraints | Minimise; each should be justified |
| High float | Very large float often signals missing logic |
| Long durations | Break down long activities so progress can be measured |
| Resources | Critical resources assigned and levelled |
| Critical path test | Delay one critical activity; the finish date should move by the same amount |

## Near-critical paths and resources

The critical path is not the only thing to watch. Paths with small float are **near-critical** and can become critical after a minor slip. Resource constraints also matter: if the same crane or specialist team is needed on two parallel activities, the resource-constrained path (sometimes called the critical chain concept) can be longer than the logic-only critical path.

## Common mistakes

- Using constraints instead of logic to force a desired end date.
- Activities with no successors ("open ends"), making float meaningless.
- Reporting "percent complete" on 60-day activities, which cannot be verified.
- Ignoring near-critical paths.
- Treating the baseline schedule as a static document rather than updating it every period with actual dates and remaining durations.

## AI note

Modern scheduling assistants can scan a schedule for open ends, long lags or suspicious constraints and propose logic fixes in seconds. Treat these as suggestions: a planner must confirm every change, because only people who understand the work can judge whether a dependency is real.

## Hands-on: CPM in Excel and in Python

**Excel.** One row per activity; predecessors in separate columns so formulas stay simple.

```text
Columns: A ID | B Dur | C Pred1 | D Pred2 | E ES | F EF
E2 (A)  0
E3      =IF(D3="", INDEX($F:$F, MATCH(C3,$A:$A,0)),
            MAX(INDEX($F:$F, MATCH(C3,$A:$A,0)), INDEX($F:$F, MATCH(D3,$A:$A,0))))
F2      =E2+B2
```

For the backward pass add `G LF`, `H LS` and `I TF = H2-E2`; LF is the `MIN` of successors' LS. Conditional-format rows where `I = 0`.

**Python.** A compact CPM for checking an export from Primavera P6 or Microsoft Project (finish-to-start links only):

```python
acts = {  # id: (duration, [predecessors])
    "A": (3, []), "B": (5, ["A"]), "C": (10, ["A"]), "D": (4, ["B"]),
    "E": (6, ["C", "D"]), "F": (8, ["B"]), "G": (2, ["E", "F"]),
}
es, ef = {}, {}
for a in acts:  # dict order here is already topological
    d, preds = acts[a]
    es[a] = max((ef[p] for p in preds), default=0)
    ef[a] = es[a] + d
finish = max(ef.values())
succ = {a: [b for b in acts if a in acts[b][1]] for a in acts}
lf, ls = {}, {}
for a in reversed(list(acts)):
    lf[a] = min((ls[s] for s in succ[a]), default=finish)
    ls[a] = lf[a] - acts[a][0]
for a in acts:
    print(a, es[a], ef[a], ls[a], lf[a], "float", ls[a] - es[a])
```

Output matches the table above: critical path A → C → E → G, 21 days. For real exports, sort activities topologically first and handle SS/FF links and lags, or rely on the scheduling tool and use scripts only as an independent check.

## How to measure success

- Zero open ends and no unjustified hard constraints at baseline.
- The critical path test passes (delay in = delay out).
- Near-critical paths (for example, total float under 10 working days) are listed and reviewed each period.

## Video lecture: Scheduling and the critical path

Lecture coming soon · 10 chapters · about 9 minutes. Read the full transcript below.

1. Which chain of work decides your finish date?
2. Why it matters
3. The concept: a relay race
4. Worked example one: three activities
5. Worked example two: solar installation near Lahore
6. Watch me do it: forward pass in a spreadsheet
7. Schedule quality checks
8. Common mistakes
9. AI in scheduling, and recap
10. Try this now

## Lecture transcript

### Which chain of work decides your finish date?

Every schedule, however big, answers one question above all others. Which chain of work decides our finish date? Get that wrong and you'll spend your energy on the wrong problems. I once watched a team spend three weeks chasing a design approval that had plenty of float, while the thing actually driving the finish, a procurement order, quietly slipped. In this lecture you'll learn the critical path method from first principles: the forward pass, the backward pass, total float, and how to find the critical path by hand. Then I'll show you the quality checks that separate a trustworthy schedule from a pretty Gantt chart. By the end you'll be able to calculate a small network yourself and challenge a schedule you didn't build.

### Why it matters

Why does this matter? Because not all delays are equal. A day lost on the critical path is a day lost on the whole project. A day lost on an activity with ten days of float costs you nothing at the finish, at least for now. That means the critical path tells you where to put your best people, your management attention and your recovery money. It also tells you where you have flexibility: float is time you can trade, for example to smooth resource peaks. Without the critical path, every late activity looks equally urgent, and managers end up firefighting everywhere at once, which usually means fixing nothing properly.

### The concept: a relay race

Think of a schedule as a relay race with several teams running in parallel, where some runners can't start until two batons have arrived. Here's the method. First, list activities, durations and logic. Most links are finish to start: B can't start until A finishes. Next, the forward pass. Start at day zero and move left to right. Early finish equals early start plus duration. When an activity has several predecessors, it starts at the latest of their early finishes. Then the backward pass. Start from the project finish and move right to left. Late start equals late finish minus duration. When an activity has several successors, its late finish is the earliest of their late starts. Finally, total float is late start minus early start. Activities with zero total float, in a schedule without imposed constraints, form the critical path.

### Worked example one: three activities

Let's warm up with something tiny. Activity A takes four days. After A, two activities can run in parallel: B takes six days and C takes three. The project finishes when both are done. Forward pass: A runs from day zero to day four. B runs from four to ten. C runs from four to seven. The project finishes at the later of the two, so day ten. Now the backward pass from day ten. B must finish by ten, so its late start is four. C must also finish by ten, so its late start is seven. C's float is seven minus four: three days. B's float is zero. So the critical path is A then B. If C slips by two days, nothing happens to the finish. If B slips by two days, the whole project slips by two days. Simple, but that's the entire logic of CPM.

### Worked example two: solar installation near Lahore

Now a realistic one, from the lesson text. A small solar installation for a factory near Lahore, illustrative numbers. Site survey, three days. Then structural design, five days, and panel procurement, ten days, both after the survey. Mounting installation, four days, after design. Panel installation, six days, needs both the panels and the mounting. Grid connection approval, eight days, after design. Commissioning, two days, needs installation and grid approval. Run the forward pass and commissioning finishes on day twenty-one. Run the backward pass and you find design has one day of float, grid approval has three, and survey, procurement, installation and commissioning have zero. So the critical path is survey, procure panels, install panels, commission. The team had been worrying about design and grid approval. The numbers say: chase the panel supplier.

### Watch me do it: forward pass in a spreadsheet

Let me show you how I'd check a small network in a spreadsheet, which is a brilliant way to understand what your scheduling tool is doing. I set up columns: activity, duration, predecessors, early start and early finish. For activity A, early start is zero and early finish is start plus duration, three. For B and C, early start equals A's early finish. For E, which needs both C and D, I type equals MAX of C's early finish and D's early finish. That returns thirteen. Early finish becomes nineteen. G takes the max of E and F, nineteen, and finishes on twenty-one. Then I load the same seven activities into Primavera P6 or Microsoft Project, schedule it, and compare. If the tool disagrees with my hand calculation, I've found a hidden constraint, a calendar issue or a lag I didn't know about.

### Schedule quality checks

Before you baseline any schedule, run a quality check. Here are the checks I never skip. Missing logic: every activity except the start and finish should have a predecessor and a successor. An open end makes float meaningless. Hard constraints: imposed dates override logic and can hide real delays, so each should be justified. Leads and long lags: they obscure what's really happening, so replace a long lag with a real activity, like concrete curing. Very high float: often a sign of missing logic. Long durations: break them down so progress can be measured. And my favourite, the critical path test. Delay one critical activity by, say, ten days. The finish date should move by exactly ten days. If it doesn't, something in your logic is broken, and you've found it before your client's claims consultant does.

### Common mistakes

The mistakes. First, using constraints instead of logic to force the end date someone wants. The schedule then tells you what you hoped, not what's true. Second, open ends: activities with no successors. Third, reporting percent complete on sixty-day activities. Nobody can verify that, and it lets optimism leak into the numbers. Fourth, ignoring near-critical paths. A path with two days of float is one small slip away from becoming critical. Watch the top few paths, not just the one. And finally, treating the baseline as a static document. The schedule has to be updated every period with actual dates and realistic remaining durations, otherwise the forecast finish never moves until it's too late to act.

### AI in scheduling, and recap

A quick word on AI. Scheduling assistants can now scan a schedule with thousands of activities and flag open ends, long lags, suspicious constraints and unrealistic durations in seconds, and some will propose logic fixes. That's a great first pass. But treat every suggestion as exactly that. A dependency is only real if someone who understands the work says it is. So, to recap. The forward pass gives you early dates. The backward pass gives you late dates. Total float is the difference. Zero-float activities form the critical path, and near-critical paths deserve almost as much attention. And no schedule should be baselined until it passes the quality checks.

### Try this now

Here's your try-this-now. Take the solar example from the lesson. Add a new activity, H, safety training, four days, which must follow the site survey and must finish before panel installation can start. Recompute the forward pass. Does the finish date change? Does the critical path change? Work it out on paper or in a spreadsheet first, then, if you have access to P6 or Microsoft Project, build it in the tool and see whether you agree. Here's a hint to check yourself: H finishes on day seven, and panels don't arrive until day thirteen. So what does that tell you about H's float?

## Video transcript

Welcome to scheduling and the critical path. Every project schedule answers one question above all others: which chain of work decides our finish date? That chain is the critical path. Here is how you find it. First, list your activities, their durations, and their logic. Most links are finish-to-start: one activity cannot start until another finishes. Next, run the forward pass. Start at day zero and move left to right. Each activity's early finish is its early start plus its duration. When an activity has several predecessors, it can only start when the latest of them finishes. Then run the backward pass. Start at the project finish and move right to left. Each activity's late start is its late finish minus its duration. When an activity has several successors, its late finish is the earliest of their late starts. Now compare. Late start minus early start gives you total float, the amount of slip an activity can absorb without moving the end date. Activities with zero float form the critical path. In our solar project example, the team worried about design and grid approval. The numbers told a different story. Panel procurement sat on the critical path, so every day lost there was a day lost on the whole project. Two final habits separate good planners from great ones. First, watch near-critical paths, because a small slip can make them critical. Second, test your schedule: delay a critical activity and check that the finish date moves by the same amount. If it does not, your logic has a gap. AI tools can now scan schedules for missing logic and odd constraints in seconds. Use them, but always let a planner who understands the work confirm the fix.

## Key takeaways

- CPM uses forward and backward passes to find early/late dates, float and the critical path.
- Total float = LS − ES; the critical path is the longest path and usually has zero float.
- Schedule quality checks (logic, lags, constraints, durations) should pass before baselining.
- Watch near-critical paths and resource constraints, not just the logic-only critical path.

## Try it

Take the solar example, add a new activity 'H Safety training, 4 days, after A, before E', and recompute the forward pass. Does the critical path change?

- [Previous: Work breakdown structures and the integrated baseline](https://optimizeall.com/learn/project-controls-with-ai/wbs-and-baselines)
- [Next: Resource loading, levelling and schedule maintenance](https://optimizeall.com/learn/project-controls-with-ai/resources-and-schedule-maintenance)
- [All lessons of Project Controls in the AI Era](https://optimizeall.com/learn/project-controls-with-ai)