Critical Path
Identifying the critical path is the difference between a level 9–10 project plan and a screenshot of a Gantt chart — it is the one concept the C1-3 interview tests hardest on planning.
What is the critical path?
The critical path is the longest chain of dependent tasks from the start to the end of a project. It determines the minimum possible duration of the project. A dependency exists when one task (the successor) cannot start until another task (the predecessor) is finished. Any delay on a critical path task directly delays the whole project — there is no buffer.
Tasks that sit off the critical path have slack time (also called float): the amount of time they can be delayed without pushing back the project end date. Understanding which tasks have slack — and how much — is what separates a plan you can reason about from a plan that is just a list of dates.
Worked example
The diagram below models a small software project. Tasks on the critical path are highlighted in red; all durations are in days.
flowchart LR
classDef cp fill:#e53935,color:#fff,stroke:#b71c1c
classDef off fill:#1565c0,color:#fff,stroke:#0d47a1
S(["Start"]):::cp
A["Survey users<br/>3 days"]:::cp
B["Write SRS<br/>5 days"]:::cp
C["Design UI<br/>4 days"]:::cp
D["Design data model<br/>3 days"]:::off
E["Code core features<br/>8 days"]:::cp
F["Write user docs<br/>3 days"]:::off
G["Beta test<br/>4 days"]:::cp
EN(["End"]):::cp
S --> A
A --> B
B --> C
B --> D
C --> E
D --> E
E --> F
E --> G
F --> EN
G --> EN
Path durations (all durations in days):
| Path | Tasks | Total |
|---|---|---|
| Critical | Start → Survey users → Write SRS → Design UI → Code core features → Beta test → End | 24 days |
| Off-critical (data model branch) | … → Write SRS → Design data model → Code core features → … | 23 days |
| Off-critical (user docs branch) | … → Code core features → Write user docs → End | 23 days |
Walkthrough:
- Both Design UI and Design data model are predecessors of Code core features — Code cannot start until both are done. Design UI takes 4 days (done at day 12 after Survey + SRS); Design data model takes 3 days (done at day 11). Code must wait for day 12, so the UI branch controls when Code can start.
- The critical path runs: Survey users (3) → Write SRS (5) → Design UI (4) → Code core features (8) → Beta test (4) = 24 days total.
- Design data model finishes at day 11 but Code cannot start until day 12 — it has 1 day of slack.
- Write user docs (3 days) runs in parallel with Beta test (4 days) after Code core features. It finishes one day before Beta test, giving it 1 day of slack.
Slack time
Slack time is how much a task can slip without delaying the project end date. To calculate it:
Slack = Latest Start Time − Earliest Start Time
Or equivalently: how long the critical path is, minus the total duration of the chain that includes this task. If the result is zero, the task is on the critical path.
Example from the diagram above: Design data model has an earliest start of day 8 (after Survey users + Write SRS). Code core features must start no later than day 12 (so that the 24-day critical path is not extended). Design data model takes 3 days, so its latest start is day 9. Slack = Latest Start − Earliest Start = 9 − 8 = 1 day.
Image by Gcd822, CC BY-SA 4.0, via Wikimedia Commons.
Why it matters at validation
The C1-3 interview rubric explicitly requires level 9–10 students to document dependencies and the critical path (C012-Roadmap-vs-Gantt.md). A screenshot of a Roadmap View with no annotations cannot evidence this — you must add dependency arrows, highlight the critical path, and label slack time on non-critical tasks before your interview.
"Trace your critical path" is a Tier 4 interview question. The expected response is to point to your annotated plan and explain: which tasks form the chain, why each dependency exists, what the minimum project duration is, and which tasks have slack. Saying "I think these tasks are the most important ones" is not an answer — the critical path is defined by dependency chains and duration, not importance (C013-Milestones-and-Dependencies.md).
Common mistake: confusing "important tasks" with "critical path tasks." Some important tasks have slack and are not on the critical path. Some critical path tasks are routine — they are critical because of where they sit in the dependency chain, not because they are difficult.
See also
← Back to VCE Software Development Hub