The COCOMO Model told us the project needs, say, 90 person-months over about 14 months. That is a total, not a plan. On Monday morning the team needs to know which task starts first, which tasks can run in parallel, who does what, and which delays will push the delivery date.
That is the job of project scheduling. In this chapter we break a project into tasks, draw the dependencies as a network, show the plan on a Gantt chart, find the critical path with CPM, and handle uncertain durations with PERT. All numbers in the worked examples are computed step by step so you can follow (and reproduce) every value.
Project scheduling is the activity of distributing the estimated effort across the planned project duration by identifying tasks, their dependencies, durations and resources, and assigning start and end dates to each.
Basic Principles of Scheduling
Pressman lists a few principles that every schedule should follow:
Compartmentalisation: break the product and process into manageable tasks.
Interdependency: identify which tasks must wait for others and which can run in parallel.
Time allocation: give every task a start date, an end date and an effort.
Effort validation: make sure that, on any day, you have not assigned more people than you actually have.
Defined responsibilities: every task has an owner.
Defined outcomes: every task produces something (a document, code, a test report).
Defined milestones: groups of outcomes are checked at review points.
Step 1: Work Breakdown Structure (WBS)
A Work Breakdown Structure is a hierarchical decomposition of the total project work into smaller, manageable pieces called work packages, each of which can be estimated, assigned and tracked.
Library Management System
├── 1. Requirements
│ └── 1.1 Requirements analysis & SRS
├── 2. Design
│ ├── 2.1 UI prototype
│ └── 2.2 Database design
├── 3. Construction
│ ├── 3.1 Core module coding
│ ├── 3.2 UI + integration coding
│ └── 3.3 Unit testing of core modules
└── 4. Testing
└── 4.1 System testingA common rule of thumb: decompose until each work package is small enough to estimate confidently and to finish in a few days to a couple of weeks. Too coarse and you cannot track progress; too fine and the plan becomes unmanageable.
Step 2: Activities and Dependencies
For the running example, the leaf tasks become activities:
| Activity | Description | Duration (weeks) | Predecessors |
|---|---|---|---|
| A | Requirements analysis | 3 | – |
| B | UI prototype | 4 | – |
| C | Database design | 2 | A |
| D | Core module coding | 4 | A |
| E | UI + integration coding | 6 | B, C |
| F | Unit testing of core | 3 | D |
| G | System testing | 4 | E, F |
Activity Network
Dependencies are drawn as a graph. There are two notations:
Activity-on-Node (AON): activities are nodes, arrows show dependencies. Used by modern tools; no dummy activities needed.
Activity-on-Arrow (AOA): activities are arrows between event nodes. Sometimes needs dummy activities (zero duration, drawn dashed) to express a dependency correctly without creating two arrows between the same pair of nodes.
Our network in AON form:
Start ──► B(4) ─────────────┐
│ ▼
└────► A(3) ──► C(2) ──► E(6) ──► G(4) ──► Finish
│ ▲
└──► D(4) ──► F(3) ───────┘There are three paths from Start to Finish:
A → C → E → G 3 + 2 + 6 + 4 = 15 weeks
A → D → F → G 3 + 4 + 3 + 4 = 14 weeks
B → E → G 4 + 6 + 4 = 14 weeksThe project cannot finish before its longest path is done, so the minimum project duration is 15 weeks. That longest path is the critical path. Listing all paths works for small networks; CPM gives a systematic way that works for any size.
Step 3: Critical Path Method (CPM)
CPM was developed in the late 1950s (DuPont and Remington Rand) for projects where activity durations are known with reasonable confidence.
The critical path is the longest path through the activity network. Its length is the shortest possible project duration. Any delay to an activity on it delays the whole project.
The Four Times of Every Activity
| Symbol | Name | How computed |
|---|---|---|
| ES | Earliest Start | Max EF of all predecessors (0 if none) |
| EF | Earliest Finish | ES + duration |
| LF | Latest Finish | Min LS of all successors (project end if none) |
| LS | Latest Start | LF − duration |
And two kinds of slack (float):
Total float TF = LS − ES = LF − EF: how long an activity can be delayed without delaying the project.
Free float FF = min(ES of successors) − EF: how long it can be delayed without delaying any successor's earliest start.
Activities with total float = 0 form the critical path.
Forward Pass (earliest times)
Go from left to right. At a merge point, take the maximum, because an activity can start only when all its predecessors are done.
A: ES = 0 EF = 0 + 3 = 3
B: ES = 0 EF = 0 + 4 = 4
C: ES = EF(A) = 3 EF = 3 + 2 = 5
D: ES = EF(A) = 3 EF = 3 + 4 = 7
E: ES = max(EF(B), EF(C))
= max(4, 5) = 5 EF = 5 + 6 = 11
F: ES = EF(D) = 7 EF = 7 + 3 = 10
G: ES = max(EF(E), EF(F))
= max(11, 10) = 11 EF = 11 + 4 = 15
Project duration = 15 weeksBackward Pass (latest times)
Go from right to left, starting with LF = 15 for the last activity. At a branch point, take the minimum, because an activity must finish before the earliest of its successors needs to start.
G: LF = 15 LS = 15 − 4 = 11
F: LF = LS(G) = 11 LS = 11 − 3 = 8
E: LF = LS(G) = 11 LS = 11 − 6 = 5
D: LF = LS(F) = 8 LS = 8 − 4 = 4
C: LF = LS(E) = 5 LS = 5 − 2 = 3
B: LF = LS(E) = 5 LS = 5 − 4 = 1
A: LF = min(LS(C), LS(D))
= min(3, 4) = 3 LS = 3 − 3 = 0The CPM Table
| Activity | Dur | ES | EF | LS | LF | Total float | Free float | Critical? |
|---|---|---|---|---|---|---|---|---|
| A | 3 | 0 | 3 | 0 | 3 | 0 | 0 | Yes |
| B | 4 | 0 | 4 | 1 | 5 | 1 | 1 | No |
| C | 2 | 3 | 5 | 3 | 5 | 0 | 0 | Yes |
| D | 4 | 3 | 7 | 4 | 8 | 1 | 0 | No |
| E | 6 | 5 | 11 | 5 | 11 | 0 | 0 | Yes |
| F | 3 | 7 | 10 | 8 | 11 | 1 | 1 | No |
| G | 4 | 11 | 15 | 11 | 15 | 0 | 0 | Yes |
Critical path: A → C → E → G, length 15 weeks.
Total float vs free float: activity D
D has total float 1 but free float 0. Why? If D slips by one week (EF 8 instead of 7), F must start at week 8 instead of 7, so D's slip does delay its successor. But F itself had 1 week of float, so the project still ends at 15. The one week of float is shared by D and F along the path A → D → F → G. If D uses it, F has none left. Free float, by contrast, belongs to an activity alone: B's week of free float can be used without affecting anyone.
Verifying with a program
The passes are mechanical, so they are easy to code. This Python program computes the table above:
acts = { # name: (duration, predecessors), listed in dependency order
"A": (3, []), "B": (4, []), "C": (2, ["A"]), "D": (4, ["A"]),
"E": (6, ["B", "C"]), "F": (3, ["D"]), "G": (4, ["E", "F"]),
}
ES, EF, LS, LF = {}, {}, {}, {}
for a, (d, preds) in acts.items(): # forward pass
ES[a] = max((EF[p] for p in preds), default=0)
EF[a] = ES[a] + d
T = max(EF.values())
succ = {a: [s for s in acts if a in acts[s][1]] for a in acts}
for a in reversed(list(acts)): # backward pass
LF[a] = min((LS[s] for s in succ[a]), default=T)
LS[a] = LF[a] - acts[a][0]
print("Act ES EF LS LF TF FF")
for a in acts:
ff = min((ES[s] for s in succ[a]), default=T) - EF[a]
print(f" {a} {ES[a]:2} {EF[a]:2} {LS[a]:2} {LF[a]:2} {LS[a]-ES[a]:2} {ff:2}")
print("Duration:", T, " Critical:", [a for a in acts if LS[a] == ES[a]])Output:
Act ES EF LS LF TF FF
A 0 3 0 3 0 0
B 0 4 1 5 1 1
C 3 5 3 5 0 0
D 3 7 4 8 1 0
E 5 11 5 11 0 0
F 7 10 8 11 1 1
G 11 15 11 15 0 0
Duration: 15 Critical: ['A', 'C', 'E', 'G']Step 4: The Gantt Chart
A Gantt chart (Henry Gantt, 1910s) is a bar chart with time on the horizontal axis and one bar per activity. It is the most common way to communicate a schedule, because anyone can read it at a glance. Here is our project with every activity at its earliest start (░ marks free float):
Week 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
A Requirements █████████ · · · · · · · · · · · · ◄ critical
B UI prototype ████████████░░░ · · · · · · · · · ·
C DB design · · · ██████ · · · · · · · · · · ◄ critical
D Core coding · · · ████████████ · · · · · · · ·
E Integration · · · · · ██████████████████ · · · · ◄ critical
F Core testing · · · · · · · █████████░░░ · · · ·
G System test · · · · · · · · · · · ████████████ ◄ criticalDuring tracking, a second bar or shading shows actual progress against the plan, and diamonds often mark milestones.
| Gantt chart strengths | Gantt chart weaknesses |
|---|---|
| Very easy to read and explain to customers | Dependencies are not obvious (modern tools add arrows, but the classic chart has none) |
| Shows parallel work and resource loading over time | Does not by itself identify the critical path |
| Good for tracking planned vs actual progress | Becomes cluttered for hundreds of tasks |
So in practice CPM/PERT is used to compute the schedule, and the Gantt chart is used to present and track it.
Step 5: PERT for Uncertain Durations
CPM assumes each duration is known. In software, durations are rarely certain. PERT (Program Evaluation and Review Technique), developed in 1958 for the US Navy's Polaris missile programme, takes three estimates per activity:
a = optimistic time (everything goes right)
m = most likely time
b = pessimistic time (things go wrong, but not catastrophically)
Expected time te = (a + 4m + b) / 6
Standard deviation σ = (b − a) / 6, variance σ² = ((b − a) / 6)²
These come from assuming each activity's duration follows a beta distribution. The project's expected duration is the sum of te along the critical path, and (assuming independent activities) its variance is the sum of the variances along that path. By the central limit theorem the total is treated as approximately normal, so
Z = (T − TE) / σpath, P(finish by T) = Φ(Z)
Worked Example
The same project now has three-point estimates (weeks). Find the expected duration, the probability of finishing within 17 weeks, and the deadline that gives 95% confidence.
| Activity | a | m | b | te = (a+4m+b)/6 | σ² = ((b−a)/6)² |
|---|---|---|---|---|---|
| A | 2 | 3 | 4 | 3 | 0.111 |
| B | 2 | 4 | 6 | 4 | 0.444 |
| C | 1 | 2 | 3 | 2 | 0.111 |
| D | 2 | 4 | 6 | 4 | 0.444 |
| E | 3 | 5 | 13 | 6 | 2.778 |
| F | 1 | 3 | 5 | 3 | 0.444 |
| G | 2 | 4 | 6 | 4 | 0.444 |
Check E: te = (3 + 20 + 13) / 6 = 36 / 6 = 6; σ = 10 / 6 ≈ 1.667; σ² ≈ 2.778. Note that E's most likely time is 5, but its long pessimistic tail pulls the expected time up to 6.
The expected times equal the CPM durations, so the critical path is again A → C → E → G.
T_E = 3 + 2 + 6 + 4 = 15 weeks
σ²_path = 0.111 + 0.111 + 2.778 + 0.444 = 3.444
σ_path = √3.444 ≈ 1.856 weeks
P(finish within 17 weeks):
Z = (17 − 15) / 1.856 ≈ 1.08
P = Φ(1.08) ≈ 0.86 → about 86%
P(finish within 15 weeks):
Z = 0 → P = 0.50 → only a coin toss!
Deadline for 95% confidence (Z = 1.645):
T = 15 + 1.645 × 1.856 ≈ 18.05 → about 18 weeksThis is the most important practical lesson of PERT: the expected duration is only a 50% promise. If you tell the customer "15 weeks", you will be late about half the time. A commitment should include a buffer based on the variance.
A Limitation: Near-Critical Paths
PERT looks only at the critical path's variance. But path B → E → G has mean 14 and variance 0.444 + 2.778 + 0.444 = 3.667, which is larger than the critical path's. Such a near-critical path can turn out to be the longest in reality, so the true probability of finishing within 17 weeks is somewhat lower than the 86% PERT reports. PERT therefore tends to be optimistic. Monte Carlo simulation of the whole network avoids this problem.
Shortening a Schedule: Crashing and Fast-Tracking
If the 15-week plan is too long, a manager has two standard options:
Crashing: add resources to shorten a critical activity, at extra cost. Always crash the cheapest critical activity first.
Fast-tracking: overlap activities that were planned in sequence (for example, start coding parts of E before C is completely finished), accepting more risk of rework.
Example: crashing E from 6 to 5 weeks shortens A → C → E → G to 14 weeks. But now A → D → F → G (14) and B → E → G (13) matter: the project is 14 weeks with two critical paths. To go below 14, you must shorten both critical paths together, for example by crashing A or G, which lie on both. Shortening only one path no longer helps. Also remember Brooks' Law: adding people to software tasks has limits.
CPM vs PERT
| Aspect | CPM | PERT |
|---|---|---|
| Durations | Deterministic (one estimate) | Probabilistic (three estimates) |
| Focus | Time–cost trade-off, crashing | Uncertainty, probability of meeting deadlines |
| Origin | DuPont / Remington Rand, 1957–58 | US Navy Polaris programme, 1958 |
| Best for | Repetitive, well-understood work | New, research-like or uncertain work |
| Output | Critical path, floats | Critical path, expected duration, variance, probability |
In practice the two are often combined: PERT's expected times are fed into CPM's forward and backward passes, exactly as we did above.
Common Mistakes
Taking the minimum at a merge in the forward pass. Use the max of predecessors' EF going forward, and the min of successors' LS going backward.
Calling the shortest path critical. The critical path is the longest path.
Adding standard deviations. Add the variances along the path, then take the square root.
Summing variances of all activities. Only activities on the critical path are included.
Using (b − a)/6 as the variance. That is σ; the variance is its square.
Confusing total and free float. Total float can be shared along a path; free float belongs to one activity.
Crashing a non-critical activity. It costs money and saves no time.
Exam and Interview Questions
Q1. An activity has a = 4, m = 7, b = 16 days. Find its expected time and variance.
te = (4 + 28 + 16) / 6 = 8 days. σ = 12 / 6 = 2, σ² = 4.
Q2. The critical path has expected length 40 days and variance 16. What is the probability of finishing within 44 days?
σ = 4, Z = (44 − 40) / 4 = 1, Φ(1) ≈ 0.84 (84%).
Q3. In the chapter's example, what happens if activity B takes 6 weeks instead of 4?
B's total float is 1, so a 2-week slip exceeds it by 1. Path B → E → G becomes 6 + 6 + 4 = 16 weeks, which is now the critical path. The project takes 16 weeks.
Q4. What is the difference between total float and free float?
Total float (LS − ES) is the delay an activity can absorb without delaying the project end. Free float (min ES of successors − EF) is the delay it can absorb without delaying any successor's earliest start. Free float ≤ total float always.
Q5. Why are dummy activities needed in AOA networks but not in AON networks?
In AOA, activities are arrows between events. When two activities share both start and end events, or when dependencies only partly overlap, a zero-duration dummy arrow is needed to show the logic correctly. In AON, every activity is a node and any dependency is just an arrow, so dummies are unnecessary.
Q6. Why is it risky to promise the customer the PERT expected duration?
The expected duration TE corresponds to Z = 0, a probability of only 50%. In addition, PERT ignores near-critical paths, so the real chance is usually below 50%. Commit to TE + kσ for the confidence you need (k = 1.645 for 95%).
Summary
Scheduling turns the total effort into dated, assigned tasks. Start with a WBS, then list activities, durations and dependencies.
Draw an activity network (AON or AOA). The critical path is the longest path; its length is the minimum project duration.
CPM: forward pass (ES = max EF of predecessors), backward pass (LF = min LS of successors). TF = LS − ES, FF = min ES(succ) − EF; critical activities have TF = 0.
Gantt charts present and track the schedule; they do not compute it.
PERT: te = (a + 4m + b)/6, σ² = ((b − a)/6)²; path variance = sum on critical path; Z = (T − TE)/σ.
The expected duration is only a 50% promise; near-critical paths make PERT optimistic.
Schedules are shortened by crashing (cheapest critical activity first) or fast-tracking.
Next, Risk Management deals with the events that can wreck even a perfect schedule.