Agile & Project Management
Schedule Management: Critical Path, Float and Schedule Compression
Intermediate9 min readUpdated
A schedule is a model of how work depends on other work, and its value comes from knowing which activities cannot slip. This guide works a small network end to end — forward pass, backward pass, float and two critical paths — then covers resource levelling, compression, baselines and the milestone reporting that keeps a schedule honest.
What you will learn
- Sequence activities using the four dependency types with leads and lags
- Estimate durations with analogous, parametric and three-point techniques
- Calculate a critical path, total float and free float on a small network by hand
- Distinguish resource levelling from smoothing and predict their effect on the schedule
- Compare crashing and fast tracking and control changes against a schedule baseline
A schedule is not a list of dates. It is a model of how the work depends on other work, and its real output is the answer to one question: which activities, if they slip by a day, move the end date by a day? Everything else — the bar chart, the milestone report, the resource histogram — is presentation on top of that model.
This guide builds the model from the ground up on a small example you can follow with a pencil, then covers what to do once you have it: levelling resources, compressing a schedule that is too long, and keeping a baseline meaningful when reality diverges from it. It assumes you already have a decomposition of the work, which the project management fundamentals guide covers.
From work packages to a sequence
Scheduling starts by turning each work package into one or more activities — the verbs, where the breakdown structure held the nouns — and then deciding what must precede what. Two disciplines pay off immediately: every activity gets exactly one owner, and every activity has a clear completion test, so that "in progress" cannot last for weeks.
Dependencies come in four flavours, and using the right one prevents a great deal of artificial serialisation.
| Type | Meaning | Example |
|---|---|---|
| Finish to start (FS) | B cannot start until A finishes | Test cannot start until the build finishes |
| Start to start (SS) | B cannot start until A starts | Documentation starts once development starts |
| Finish to finish (FF) | B cannot finish until A finishes | Training cannot complete until content is final |
| Start to finish (SF) | B cannot finish until A starts | The old service runs until the new one is live |
FS covers the overwhelming majority. SS and FF are what let overlapping work be modelled honestly instead of forcing a false sequence. SF is rare and mostly appears in cutovers.
Lead is negative wait — starting a successor before its predecessor is finished, such as beginning integration testing two days before the last component is complete. Lag is imposed waiting that consumes no effort: concrete curing, a two-week regulatory notice period, a database re-index that runs overnight. Model lags explicitly rather than inflating an activity's duration, because a lag has no cost and cannot be crashed, and hiding it inside a duration makes the schedule lie about both.
Distinguish mandatory dependencies, which are inherent in the work, from discretionary ones, which reflect a preference or a habit. Discretionary dependencies are where schedule compression usually finds its slack, so mark them when you create them.
Estimating durations
Three techniques cover most needs, and they are usually combined.
Analogous estimating scales from a comparable past activity: the last migration of similar size took nine days, this one is somewhat larger, call it twelve. Fast, cheap, and only as good as the comparability.
Parametric estimating uses a measured rate: 40 screens at 1.5 days per screen is 60 days. It is the most defensible technique when a rate genuinely exists, and dangerous when the parameter is invented to justify a number.
Three-point estimating captures uncertainty explicitly with an optimistic, most likely and pessimistic value. The beta-weighted form associated with PERT is:
Expected duration te = (O + 4M + P) / 6
Standard deviation sd = (P - O) / 6
Backend build: O = 6 days, M = 9 days, P = 18 days
te = (6 + 36 + 18) / 6 = 10 days
sd = (18 - 6) / 6 = 2 days
Interpretation: ~10 days expected; roughly 95% confidence
of finishing within te + 2sd = 14 days.
Note how the long tail pulls the expected value above the most likely one — that asymmetry is the reality of software activities, where things go wrong more often than they go unusually well. Team-level relative sizing is a different tool for a different question, covered in estimation and planning.
A worked critical path
Take a small delivery with nine activities. Durations are in working days.
| ID | Activity | Duration | Predecessors |
|---|---|---|---|
| A | Requirements confirmed | 5 | — |
| B | Data model design | 4 | A |
| C | Interface design | 6 | A |
| D | Backend build | 10 | B |
| E | Frontend build | 8 | C |
| F | Migration scripts | 6 | B |
| G | Integration and system test | 5 | D, E |
| H | Migration dry run | 3 | F, G |
| I | Go-live and handover | 2 | H |
The forward pass works left to right, computing the earliest each activity can start and finish. An activity starts as soon as all its predecessors have finished, so where several converge you take the largest finish. The backward pass then works right to left from the project end, computing the latest each activity can start and finish without pushing that end date; where an activity has several successors you take the smallest late start.
| ID | Early start | Early finish | Late start | Late finish | Total float |
|---|---|---|---|---|---|
| A | 0 | 5 | 0 | 5 | 0 |
| B | 5 | 9 | 5 | 9 | 0 |
| C | 5 | 11 | 5 | 11 | 0 |
| D | 9 | 19 | 9 | 19 | 0 |
| E | 11 | 19 | 11 | 19 | 0 |
| F | 9 | 15 | 18 | 24 | 9 |
| G | 19 | 24 | 19 | 24 | 0 |
| H | 24 | 27 | 24 | 27 | 0 |
| I | 27 | 29 | 27 | 29 | 0 |
The project takes 29 days, and two critical paths exist: A–B–D–G–H–I and A–C–E–G–H–I both total 29. Only F carries float — nine days of it, because although the scripts are ready on day 15, the dry run cannot begin until integration testing completes on day 24. F's free float is also nine, since delaying it up to that point affects no successor's earliest start.
Two practical readings follow. First, the migration scripts are not urgent, so borrowing that developer for a week costs nothing — the schedule tells you where slack genuinely is, which intuition rarely does. Second, because two paths are critical, shortening the backend build alone changes nothing at all: the frontend path still runs to day 19. This is the most common mistake in schedule compression, and it is only visible if you compute the network rather than eyeballing the bar chart.
Presenting and levelling
A Gantt chart renders the network as bars against a calendar. It is excellent for communication and terrible as a planning tool on its own, because a bar chart drawn by hand encodes dates without dependencies — when one bar moves, nothing else does, and the plan quietly becomes fiction. Always derive the chart from the network. Show the critical path in a distinct colour, mark milestones as diamonds, and resist the urge to display four hundred rows to a steering group when nine summary bars carry the message.
Milestones are zero-duration markers of a significant state: design approved, integration environment available, user acceptance signed. They report better than percentages because they are binary. A milestone trend chart — plotting each milestone's forecast date at every reporting period — is the single most informative schedule report available, since a line drifting steadily to the right shows a problem months before the milestone is missed.
Resources then collide with the plan. Resource levelling adjusts the schedule so demand never exceeds availability; because it can delay activities, it can extend the project end date and change which path is critical. Resource smoothing adjusts activities only within their available float, so the end date is preserved but demand is flattened only as far as float allows. If a single specialist appears on both critical paths in the example above, levelling will lengthen the project and no amount of reporting will change that.
Compressing a schedule
When the calculated end date is later than the required one, there are exactly two legitimate techniques plus one honest alternative.
Crashing adds resources to critical activities to shorten them, which costs money and does not scale linearly — doubling the team rarely halves the duration, and adding people to work already underway usually slows it. Crash the cheapest critical activity per day saved, and recompute the network after each step, because compression changes which path is critical.
Continuing the example, suppose the deadline is 25 days rather than 29:
| Activity | Path | Days saved | Cost | Cost per day |
|---|---|---|---|---|
| D Backend build | Path 1 only | 2 | 8,000 | 4,000 |
| E Frontend build | Path 2 only | 2 | 5,000 | 2,500 |
| G Integration test | Both paths | 1 | 6,000 | 6,000 |
| H Migration dry run | Both paths | 1 | 2,000 | 2,000 |
Crashing H saves a day on both paths for 2,000 — clearly first. Crashing G saves another day on both for 6,000. Crashing D or E saves nothing unless both are crashed, at a combined 13,000 for two days. So reaching 25 days costs 21,000 and touches four activities, whereas an intuitive "speed up the backend" would have spent 8,000 and saved nothing.
Fast tracking overlaps activities that were sequenced in series, usually by converting a finish-to-start dependency into a start-to-start with a lead. It costs no money and buys rework risk: starting the frontend before the interface design is complete means some of it will be built twice. Fast track discretionary dependencies first, never mandatory ones, and record the added risk in the risk register.
The honest alternative is reducing scope. It is usually cheaper and safer than either technique, and it is the option that gets raised last.
Baselines, change and tracking
Once the schedule is agreed, freeze a copy as the baseline. Everything afterwards is measured against it, and it changes only through approved change control — otherwise the plan is quietly rewritten each month to match reality and the project appears to be on time until the day it is not.
A workable change process: an impact assessment on schedule, cost and risk; a decision by whoever holds authority at that threshold; a re-baseline only if the change is approved; and a preserved record of the previous baseline. Re-baselining is legitimate after a genuine scope change and illegitimate as a way to erase a variance.
Track by measuring progress against the network, not against elapsed calendar. The questions worth asking weekly are whether any critical activity is late, how much float has been consumed on near-critical paths, whether milestone forecasts are drifting, and whether a dependency assumption has been invalidated. Schedule variance in cost terms is covered in earned value management, which converts the same information into money and gives you an index to trend.
Key takeaways
- The purpose of a schedule model is to identify which activities cannot slip; the bar chart is presentation, and drawing one without a dependency network produces a plan that cannot react.
- Use all four dependency types and model lag explicitly rather than padding durations, and mark discretionary dependencies because that is where compression finds slack.
- Compute float from a forward and backward pass; total float is slack against the end date, free float is slack that affects no successor.
- A network can have several critical paths, and compressing only one of them buys nothing — always recompute after each compression step.
- Levelling can extend the end date, smoothing cannot; if a specialist sits on two critical paths, the schedule will lengthen.
- Baseline the schedule and change it only through decisions on the record; re-baselining to erase a variance destroys the only reference you had.
Sources and further reading
Frequently asked questions
- Can a project have more than one critical path?
- Yes, and it is common once parallel workstreams converge on the same integration activity. Two critical paths double the exposure: a delay on either one moves the end date, and compressing only one of them buys nothing. Networks that develop several near-critical paths, where float is only a day or two, are fragile in the same way even though only one path is formally critical.
- What is the difference between total float and free float?
- Total float is how long an activity can slip without delaying the project end date. Free float is how long it can slip without delaying the earliest start of any immediately following activity. Free float is never greater than total float, and it is the more useful number day to day because consuming it affects nobody else, whereas consuming total float eats a buffer shared with other activities on the same path.
- Does the critical path method apply to agile teams?
- Rarely inside a sprint, where work is small and re-planned continuously and throughput forecasting suits better. It applies to the surrounding delivery: hardware lead times, contract signatures, environment provisioning, data migration windows and regulatory approvals all have hard dependencies and long durations, and those are exactly what a network diagram is good at exposing.
- How much schedule buffer should a plan contain?
- Buffer belongs at the end of a path or the project rather than hidden inside each activity, because padding added per task is consumed silently and teaches nobody anything. Size it from the risk analysis rather than by a flat percentage, and make it visible so that consuming it is a reportable event. A common practice is a project buffer of roughly a third to a half of the aggregated activity contingency that was removed.