B. Software Development · Software Development: Managing a Team Software Project

Scheduling Tools: Gantt Charts, PERT Networks, the Critical Path, Calendars and Task Boards

B1.4 B1.1About 75 minutes

Learning goals

I can turn a task list with durations and dependencies into a Gantt chart and an activity-on-node (PERT) network.
I can do a forward pass and a backward pass to find each task's earliest and latest start and finish, its slack and the critical path.
I can write a Python program that schedules a project with the critical path method.
I can convert project days into calendar dates and estimate the probability of meeting a deadline with PERT.
I can use a task board (Kanban) with work-in-progress limits to manage day-to-day work.

Words to know

activity-on-node (AON) network
A PERT-style diagram in which each task is a box (node) and arrows show which tasks must finish before others can start.

forward pass
Working from the start to find each task's earliest start (ES) and earliest finish (EF).

backward pass
Working from the end to find each task's latest finish (LF) and latest start (LS) that would not delay the project.

slack (float)
LS − ES: how many days a task can slip without delaying the project.

critical path
The chain of tasks with zero slack. Its length is the shortest possible project duration.

baseline
The approved schedule, saved so that actual progress can be compared with it later.

Kanban board
A task board with columns such as To do, In progress, Review and Done; cards move across as work progresses.

WIP limit
A work-in-progress limit: the most cards allowed in a column at once, so the team finishes work before starting more.

From a list to a plan

The last lesson produced the raw material of a schedule: tasks, durations and risks. Now we turn it into a schedule the whole team can follow. The curriculum asks you to use an appropriate project management tool (e.g., Gantt chart, PERT chart, calendar) to manage project components. Each tool answers a different question:

Gantt chart: what happens when, and what runs in parallel?
PERT (network) chart: what depends on what, and which tasks are critical?
Calendar: on which real dates?
Task board: what is everyone doing today?

Remember from Grade 11

In ICS3U you found each task's earliest start by taking the latest finish among its predecessors, found the critical path by adding up every chain, and used PERT's (O + 4M + P) ÷ 6. That works for small projects, but listing every chain becomes impossible when there are dozens of tasks. This lesson uses the systematic method professionals use: the forward and backward pass of the critical path method (CPM).

LendIt's task list

Priya grouped the WBS work packages into 12 schedulable tasks. Durations are in school days of team time.

Task	Description	Days	After
A	Requirements	2	none
B	Scope and plan	2	A
C	Data, interface design	3	B
D	Menu prototype	2	B
E	Items module	3	C
F	Loans module	5	C
G	Storage module	3	C
H	Menu code	3	D, E
I	Integration tests	3	F, G, H
J	User guide, training	4	D
K	Acceptance, delivery	2	I, J
L	Review report	1	K

LendIt's task list. Menu code (H) needs both the menu prototype (D) and the items module (E); integration tests (I) need all three modules and the menu.

The forward pass

Go through the tasks in dependency order. For each task:

ES (earliest start) = the largest EF of its predecessors (0 if it has none).
EF (earliest finish) = ES + duration.

A: 0 to 2. B: 2 to 4. C and D both start at 4: C ends at 7, D at 6. E, F and G start at 7 and end at 10, 12 and 10. H needs D (6) and E (10): ES = 10, EF = 13. J needs D: 6 to 10. I needs F (12), G (10) and H (13): ES = 13, EF = 16. K needs I (16) and J (10): 16 to 18. L: 18 to 19.

The project takes 19 days.

The backward pass

Now go backwards from the end (day 19). For each task:

LF (latest finish) = the smallest LS of its successors (the project end if it has none).
LS (latest start) = LF − duration.

L: LF 19, LS 18. K: 18, 16. I: 16, 13. J must finish before K starts: LF 16, LS 12. H: LF 13, LS 10. F and G finish before I: LF 13, so LS 8 and 10. E finishes before H: LF 10, LS 7. D finishes before H and J, so LF = min(10, 12) = 10, LS 8. C finishes before E, F and G: LF = min(7, 8, 10) = 7, LS 4. B: LF = min(4, 8) = 4, LS 2. A: LF 2, LS 0.

Slack and the critical path

Slack = LS − ES. Tasks with zero slack form the critical path: A → B → C → E → H → I → K → L (2 + 2 + 3 + 3 + 3 + 3 + 2 + 1 = 19 days). The others can slip: D by 4 days, F by 1, G by 3 and J by 6.

LendIt's activity-on-node network. Each node shows ES and EF on top and LS and LF underneath; highlighted nodes and thick arrows are the critical path. Where the top and bottom numbers match, the slack is zero.

The same schedule as a Gantt chart. Highlighted bars are critical; the dashed boxes show each other task's slack. Notice the loans module (F) has only 1 day of slack, so it is nearly critical.

Worked example

Example 1: What happens if...?

Using the schedule, answer: (a) The loans module (F) takes 7 days instead of 5. (b) The user guide (J) takes 8 days instead of 4. (c) Which single task is the riskiest to let slip, and why?

(a) F has 1 day of slack, and the change adds 2 days. New EF for F = 7 + 7 = 14, so I starts at 14 instead of 13. The project grows by 1 day to 20 days, and F becomes critical (the critical path changes to A, B, C, F, I, K, L).
(b) J has 6 days of slack and the change adds 4. EF for J = 6 + 8 = 14, still before K starts at 16. No change: 19 days.
(c) Any critical task delays the project day for day. But the loans module (F) deserves special attention: it is the longest coding task, it has the most uncertain estimate (the K5 risk from the risk register), and it has only 1 day of slack. That is why Priya starts it on day 7 with her best programmer.

(a) 20 days, and the critical path moves through F. (b) Still 19 days. (c) F: long, uncertain and nearly critical.

The critical path method as a program

The forward and backward passes are algorithms, so a program can do them. Store durations and predecessors in dictionaries. The forward pass uses max(..., default=0) so a task with no predecessors starts at 0. The backward pass finds each task's successors (tasks that list it as a predecessor) and uses min(..., default=end).

names = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"]

days = [2, 2, 3, 2, 3, 5, 3, 3, 3, 4, 2, 1]

after = [[], ["A"], ["B"], ["B"], ["C"], ["C"], ["C"], ["D", "E"],

["F", "G", "H"], ["D"], ["I", "J"], ["K"]]

dur = dict(zip(names, days))

pred = dict(zip(names, after))

es, ef = {}, {}

for t in names: # forward pass

es[t] = max((ef[p] for p in pred[t]), default=0)

ef[t] = es[t] + dur[t]

end = max(ef.values())

ls, lf = {}, {}

for t in reversed(names): # backward pass

succ = [s for s in names if t in pred[s]]

lf[t] = min((ls[s] for s in succ), default=end)

ls[t] = lf[t] - dur[t]

for t in names:

slack = ls[t] - es[t]

line = f"{t} ES {es[t]:2} EF {ef[t]:2} LS {ls[t]:2} LF {lf[t]:2} slack {slack}"

if slack == 0:

line += " critical"

print(line)

print("Project length:", end, "days")

Output: one line per task, such as A ES 0 EF 2 LS 0 LF 2 slack 0 critical and D ES 4 EF 6 LS 8 LF 10 slack 4, ending with Project length: 19 days. Tasks A, B, C, E, H, I, K and L are marked critical; D, F, G and J have slack 4, 1, 3 and 6.

Both loops depend on the list being in dependency order: every task appears after all of its predecessors. Then the forward pass always finds its predecessors' finish times ready, and the backward pass (which runs in reverse) always finds its successors' start times ready. Putting tasks in such an order is called a topological sort, and you will meet it again in university courses on graphs and algorithms.

From project days to the calendar

Team members, clients and teachers think in dates, not "day 13". Priya's project starts on Monday, November 2, 2026. Day 0 is that Monday, and only weekdays count. The function below steps forward one calendar day at a time and counts only Monday to Friday (weekday() gives 0 for Monday up to 6 for Sunday). A task that occupies days ES to EF − 1 runs from add_workdays(day0, es) to add_workdays(day0, ef - 1).

from datetime import date, timedelta

def add_workdays(start, n):

"""Return the date that is n working days (Monday to Friday) after start."""

d = start

while n > 0:

d += timedelta(days=1)

if d.weekday() < 5: # 0 = Monday ... 4 = Friday

n -= 1

return d

day0 = date(2026, 11, 2) # Monday, November 2, 2026

plan = [("C design", 4, 7), ("F loans module", 7, 12),

("I integration", 13, 16), ("L review", 18, 19)]

for name, es, ef in plan:

first = add_workdays(day0, es)

last = add_workdays(day0, ef - 1)

print(f"{name:<16}{first:%a %b %d} to {last:%a %b %d}")

Output: C design Fri Nov 06 to Tue Nov 10 / F loans module Wed Nov 11 to Tue Nov 17 / I integration Thu Nov 19 to Mon Nov 23 / L review Thu Nov 26 to Thu Nov 26 (one line each)

The whole project ends on day 19, which is Thursday, November 26, 2026. The centre's deadline is Friday, December 11, 2026, the end of week 6, so the plan has 11 working days of buffer for the risks in the register. Priya saves this schedule as the baseline, so that later status reports can compare actual progress with it. A real calendar should also block out school holidays, PA days and exam weeks; the program could skip a list of such dates in the same way it skips weekends.

How likely is the deadline? (PERT)

PERT can estimate the chance of finishing by a date. Add the expected times along the critical path for the expected project length, and add the variances along the critical path for its variance. Then use the normal distribution, as in MDM4U.

This method ignores near-critical paths (like the one through F), so treat the result as optimistic.

Worked example

Example 2: The chance of an early delivery

Denise asks whether LendIt could be delivered by the end of day 22 instead (Tuesday, December 1, 2026). The critical path's expected length is 19 days, and the variances of its tasks add to 4 days². Estimate the probability of finishing by day 22.

σ of the path = √4 = 2 days.
z = (22 − 19) ÷ 2 = 1.5.
From the standard normal table, P(Z ≤ 1.5) ≈ 0.933.
Caution: F's path is only 1 day shorter, and it has a large variance, so the true probability is somewhat lower.

About a 93% chance (an optimistic estimate). Priya tells Denise "very likely, but not certain", and keeps December 11 as the promised date.

Task boards for the day-to-day

A Gantt chart is great for the big picture, but on a Tuesday morning the question is: what should I do now? Agile teams use a task board, often called a Kanban board (from a Japanese word for a sign or card). Each task is a card. Cards move from To do to In progress to Review to Done.

The key idea is the work-in-progress (WIP) limit. If "In progress" may hold at most 3 cards, nobody can start a fourth task until one is finished. This stops the common problem of five tasks that are all "90% done". A free online board, a shared spreadsheet or sticky notes on a wall all work.

LendIt's board in week 2. In progress is at its limit of 3, so the next person who is free should help review the items module rather than start the search feature.

Just for fun

PERT was created in the late 1950s for the U.S. Navy's Polaris missile-submarine program, which had thousands of contractors to coordinate. Your four-person team project is, thankfully, a little smaller.

Hands-on activity

Project step 4: Schedule your project

You need: your WBS and estimates from project step 3, graph paper or a spreadsheet, and Python.

Group your work packages into 10 to 15 schedulable tasks. Give each a letter, a duration (in days of project time) and its predecessors.
Do the forward and backward pass by hand on a copy of the task table. Find the critical path and every task's slack.
Type your tasks into the CPM program from this lesson and check your hand calculations. (Make sure your list is in dependency order.)
Draw a Gantt chart (graph paper, a spreadsheet with coloured cells, or a free online tool). Mark the critical tasks and at least two milestones as diamonds.
Use the calendar program with your real start date to turn project days into dates. Block out days you know you cannot work (holidays, tournaments, exams).
Set up a task board with four columns and a WIP limit, on paper, a whiteboard or a free online board.
Save the schedule as your baseline in docs/schedule.md with a picture of the Gantt chart.

What to look for: hand and program results agree; the critical path makes sense (the longest coding task is on it or close to it); there is buffer before the real deadline.

Your turn

A task has predecessors that finish on days 5, 9 and 7. What is its ES?

A task has successors whose LS values are 12, 10 and 15. What is its LF?

Task G has ES 7, duration 3 and LF 13. Find EF, LS and slack.

Why is task D's LF the minimum of 10 and 12 rather than the maximum?

The user guide (J) slips by 5 days. Does the project finish later? Explain.

What date is day 5 of the LendIt project (day 0 is Monday, November 2, 2026)?

What is a WIP limit, and what problem does it prevent?

More practice: warm-up

What does the forward pass calculate?

What is the formula for slack?

What is the slack of a critical task?

Name the four columns of a typical Kanban board.

What is a baseline schedule?

More practice: on your own

Tasks: P (3 days, none), Q (2, after P), R (5, after P), S (4, after Q), T (2, after R and S). Do the forward pass and find the project length.

For the same project, do the backward pass and give each slack. What is the critical path?

In the CPM program, what would happen if task H were listed before E in the names list (with the same predecessors)? Explain.

Using add_workdays, what date is day 10 if day 0 is Monday, November 2, 2026?

The critical path of a project has expected length 30 days and variance 9 days². Estimate the probability of finishing within 33 days.

Challenge

Jordan suggests splitting the loans module (F, 5 days) into F1 (3 days, after C) and F2 (2 days, after F1), with Luc doing F2 while Jordan starts on something else. Does this change the project length? What does it change?

Modify the calendar function so that it also skips a list of holidays, such as holidays = [date(2026, 12, 25)]. Write the changed condition.

The PERT estimate in Example 2 used only the critical path. Explain why this tends to overestimate the probability of finishing on time, using LendIt's path through F.

Check your understanding

Quiz

A task's predecessors finish on days 4, 11 and 8. What is its earliest start?

A task has ES = 6, EF = 9, LS = 8 and LF = 11. What is its slack?

In the backward pass, a task's latest finish is:

A non-critical task has 3 days of slack and slips by 5 days. What happens to the project?

Which tool best answers "What is everyone working on today?"

A critical path has expected length 20 days and σ = 2 days. Estimate P(finish within 24 days).

For parents and teachers

Big idea: B1.4 asks students to use project management tools such as Gantt charts, PERT charts and calendars to manage project components. This lesson goes beyond Grade 11 with the forward and backward passes of the critical path method, a Python scheduling program, real calendar dates, a PERT probability estimate (linked to MDM4U) and Kanban task boards.

How to help: Ask to see the Gantt chart and the real dates. Point out family events, holidays and exam weeks that the schedule must avoid. Ask "What happens if this task is two days late?" and see if your teen can answer from the slack.

Common difficulties:

Using the smallest predecessor finish (instead of the largest) in the forward pass, or the largest successor start (instead of the smallest) in the backward pass.
Forgetting that weekends (and holidays) are not working days.
Treating the PERT probability as exact. It ignores near-critical paths and depends on honest estimates.