ποΈ Critical Path Method (CPM)
PMP Exam Complete Study Guide β In-Depth, Examples, Tips, Cheat Sheet & Quiz
Definition & Purpose
The CPM (Critical Path Method) is a schedule network analysis technique used to determine the longest path through a project schedule network β the path that determines the project duration. Activities on this path have zero float, meaning any delay to even one activity will delay the entire project.
CPM answers three vital questions every PM must know:
- π What is the earliest the project can finish?
- π Which activities cannot be delayed without delaying the project?
- βοΈ Where can I compress the schedule (if I must)?
History & Context
CPM was developed in the late 1950s by Du Pont Corporation (with Remington Rand) for chemical plant construction. Simultaneously, the U.S. Navy developed PERT for the Polaris missile program. Both are network-based scheduling methods, but CPM uses deterministic durations while PERT uses probabilistic estimates.
CPM is referenced in the PMBOK Guide under the Develop Schedule process (Section 6.5). It is used in predictive (waterfall) project approaches. In agile, similar concepts exist (e.g., critical chain), but CPM specifically applies to predictive environments.
Activities & Network Basics
| Term | Meaning | PMP Context |
|---|---|---|
| Activity | A discrete, scheduled unit of work | Has duration, resources, predecessors |
| Predecessor | Activity that must start/finish before another | Defines dependency arrows |
| Successor | Activity that follows a predecessor | Cannot begin until predecessor condition met |
| Network Diagram | Visual map of activity sequence and flow | PDM (AON) most common in PMBOK |
| Path | Sequence of connected activities from start to finish | Multiple paths exist; longest = Critical Path |
| Critical Path | Longest duration path with zero float | Determines project end date |
Forward Pass & Backward Pass
To find the critical path, you perform two mathematical passes through the network:
Start at the beginning, move left-to-right through the network.
Start at the project end date, move right-to-left through the network.
Float / Slack
Float (also called Slack) is the amount of time an activity can be delayed without delaying the project finish date. Activities on the critical path always have zero float.
- Positive Float β Activity has flexibility; NOT on critical path
- Zero Float β Activity IS on the critical path; any delay = project delay
- Negative Float β Schedule is already behind! Compression needed immediately
You're managing a bridge rehabilitation project. Activity "Paint structural steel" has 5 days of float. That means you can delay starting it by up to 5 days before it affects the project handover. But "Pour concrete deck" has zero float β it's on the critical path. If concrete pours start 1 day late due to weather, the whole project moves 1 day.
EF = ES + Duration β 1 (activity-on-node / day-based)
ES (next activity) = EF (predecessor) + 1
ES (successor) = EF (predecessor)
LS = LF β Duration
LF (predecessor) = LS (successor) β 1 (day-based)
LF (predecessor) = LS (successor)
Free Float = ES (successor) β EF (current activity)
Critical Path Float = 0
Always crash the cheapest activity on the critical path first!
- Most PMP exam questions use the duration-only method (ES + Duration = EF). Don't subtract 1.
- If the project starts on Day 0: first activity ES = 0, EF = Duration.
- Float = LS β ES OR LF β EF (both give same result β use as a check!)
AON vs AOA
| Type | Full Name | Nodes Represent | Arrows Represent | PMBOK Preference |
|---|---|---|---|---|
| AON | Activity on Node | Activities (boxes) | Dependencies | β YES β PDM |
| AOA | Activity on Arrow | Events (nodes) | Activities | β οΈ Old method; rarely used |
PMBOK uses the Precedence Diagramming Method (PDM), which is AON. Each activity is a box (node) with ES, EF, LS, LF, Duration, and Float displayed.
Activity Node Box Format
ββββββββββββββββββββββββββββββββ β ES = 3 | EF = 7 β βββββββββ Activity Name ββββββββ β LS = 5 | LF = 9 β βββββββββ Duration = 4 βββββββββ β Float = 2 β ββββββββββββββββββββββββββββββββ
β² Interactive CPM network diagram β Critical Path highlighted in red
Dependency Types (Logical Relationships)
| Relationship | Abbreviation | Meaning | Most Common? |
|---|---|---|---|
| Finish-to-Start | FS | B can't START until A FINISHES | β Most common |
| Start-to-Start | SS | B can't START until A STARTS | β‘ Overlap work |
| Finish-to-Finish | FF | B can't FINISH until A FINISHES | β‘ Parallel close |
| Start-to-Finish | SF | B can't FINISH until A STARTS | β Rarely used |
Step-by-Step Method
Step 2: Identify dependencies and build the network diagram.
Step 3: Perform Forward Pass β Calculate ES and EF for all activities.
Step 4: Perform Backward Pass β Calculate LS and LF for all activities.
Step 5: Calculate Float = LS β ES for each activity.
Step 6: Activities with Float = 0 are on the Critical Path.
Step 7: The Critical Path = the longest path through the network.
Worked Calculation Example
Project: Software Module Release β 5 Activities
| Activity | Predecessor | Duration (days) |
|---|---|---|
| A β Requirements | None (Start) | 4 |
| B β UI Design | A | 5 |
| C β Backend Dev | A | 8 |
| D β Integration | B, C | 3 |
| E β Testing | D | 4 |
Paths through the Network:
- Path 1: A β B β D β E = 4+5+3+4 = 16 days
- Path 2: A β C β D β E = 4+8+3+4 = 19 days β CRITICAL PATH
Forward/Backward Pass Results:
| Activity | ES | EF | LS | LF | Float | Critical? |
|---|---|---|---|---|---|---|
| A | 0 | 4 | 0 | 4 | 0 | β YES |
| B | 4 | 9 | 7 | 12 | 3 | No (3 days float) |
| C | 4 | 12 | 4 | 12 | 0 | β YES |
| D | 12 | 15 | 12 | 15 | 0 | β YES |
| E | 15 | 19 | 15 | 19 | 0 | β YES |
π΄ Critical Path: A β C β D β E = 19 days. Activity B has 3 days of float and is NOT critical.
Multiple Critical Paths
A project can have more than one critical path. This happens when two or more paths have the same (longest) duration. This is actually more risky β any delay on either path delays the project, and you have less scheduling flexibility.
On a highway project, both the paving subcontract chain (Path A: 22 weeks) and the utility relocation chain (Path B: 22 weeks) are the longest. Both are critical. The PM must manage resources carefully on both paths simultaneously β a single delay to either one pushes the project completion date.
| Float Type | Formula | What it Tells You |
|---|---|---|
| Total Float | LS β ES or LF β EF | How long activity can delay without delaying PROJECT end |
| Free Float | ES(succ) β EF(current) | How long activity can delay without delaying SUCCESSOR |
| Project Float | Customer deadline β Calculated end date | Schedule buffer before customer deadline is missed |
Activity X: EF=10, Successor Y has ES=14. Free Float = 14β10 = 4 days. But Total Float for X = LSβES = 7. Meaning: you can delay X by 4 days without affecting Y at all; delay by up to 7 days total without delaying the project end β but days 5β7 of delay would push Y's start back and consume Y's float.
| Feature | CPM | PERT |
|---|---|---|
| Duration Estimate | Single (deterministic) | Three-point (optimistic, most likely, pessimistic) |
| Uncertainty | Low β well-known work | High β R&D, first-time projects |
| Developed by | Du Pont (1957) | U.S. Navy (1958) |
| Focus | Time & Cost | Time & Uncertainty |
| Output | Critical Path, Float | Probability of meeting deadline |
| PMP Application | Develop Schedule (6.5) | Estimate Activity Durations (6.4) |
Standard Deviation = (P β O) / 6
O = Optimistic | M = Most Likely | P = Pessimistic
If the question mentions "single duration estimate" β CPM. If it mentions "three-point estimate," "uncertainty," or "probabilistic" β PERT or Monte Carlo. If asked which technique finds the critical path β always answer CPM (or PDM/Network Analysis).
When the calculated project end date is later than the required end date, you must compress the schedule. You should always compress activities on the Critical Path β compressing non-critical activities wastes money without helping the deadline.
Crashing
Crashing = Adding resources (cost) to reduce duration. Works best when the cost of compression is less than the penalty for delay.
- Always crash the cheapest activity on the critical path first
- Watch out: crashing one activity might make a non-critical path become critical
- Crashing has limits β you can only crash up to the crash limit
Critical Path: Survey (2d) β Excavation (10d) β Concrete pour (8d) β Cure (5d) = 25 days. Client needs it in 22 days. Options:
- Crash Excavation by 3 days: Add $6,000 ($2,000/day)
- Crash Concrete pour by 3 days: Add $9,000 ($3,000/day)
Decision: Crash Excavation first (cheaper per day). 3 days Γ $2,000 = $6,000 total crash cost. Project now = 22 days β
Fast Tracking
Fast Tracking = Performing activities in parallel that were originally planned sequentially. No extra cost, but high risk β increases rework potential if earlier activities change.
| Crashing | Fast Tracking | |
|---|---|---|
| Method | Add resources / cost | Overlap sequential activities |
| Cost Impact | Increases cost | No direct cost increase |
| Risk Impact | Usually low | Increases rework risk |
| Best for | Cost-flexible projects | Cost-constrained projects |
- If a question says "no budget available" β Fast Tracking first
- If a question says "risk must be minimized" β Crashing
- PMBOK says: use fast tracking first, then crashing (to avoid cost overruns)
Activities: A(Mobilize, 3d) β B(Clearing, 5d) β C(Grading, 8d) β D(Paving, 7d). Also: A β E(Utility Install, 12d) β D.
- Path 1: AβBβCβD = 3+5+8+7 = 23 days
- Path 2: AβEβD = 3+12+7 = 22 days
Critical Path = AβBβCβD (23 days). Activity E has 1 day of float. PM should focus resources on B, C, D.
Sponsor asks: "Can we launch 2 weeks earlier?" Critical path is 16 weeks. What do you do?
- First: Identify critical path activities that can be overlapped (fast track)
- Example: Start QA testing while development finishes last module (risky but saves 1 week)
- Then: Crash the remaining 1 week by adding testers (costs $5,000)
- Report: 2-week compression achievable for $5,000 + increased rework risk
Project baseline shows end date = Nov 30. After monthly update, backward pass shows the critical path has -5 days float. What happened?
- A critical path activity slipped by 5 days
- The project is already 5 days behind schedule
- PM must immediately crash and/or fast-track to recover
- PMP exam would ask: "What should the PM do FIRST?" β Analyze variance and develop recovery plan
After applying Resource Leveling to your schedule, some activities are delayed to resolve resource conflicts. This delay may change the critical path! The PM must re-run CPM analysis after resource leveling.
- The critical path is ALWAYS the LONGEST path, not the most important or most risky.
- Activities on the CP have zero total float. If a question gives you float β 0, that activity is NOT on the CP.
- When multiple paths exist with the same duration, the project has multiple critical paths β higher risk!
- Adding resources to non-critical activities does NOT shorten the project.
- Float can be NEGATIVE β means the schedule is already overrun.
- Forward pass β use MAX when multiple predecessors converge. Backward pass β use MIN.
- The project duration = length of the critical path (not the sum of all activities).
- CPM is used in the Develop Schedule (6.5) process.
- Resource leveling can lengthen the critical path.
- Fast tracking = overlap activities; Crashing = add resources.
- When schedule is behind, always compress the critical path first.
- The Schedule Network Analysis includes CPM, resource leveling, and what-if scenario analysis.
- Mandatory dependencies ("hard logic") cannot be changed. Discretionary dependencies ("soft logic") can be adjusted (fast tracking).
- CPM uses deterministic durations. PERT uses probabilistic (3-point).
- If asked what determines the project end date β Critical Path length.
| Item | Formula |
|---|---|
| Early Finish | EF = ES + Duration |
| Late Start | LS = LF β Duration |
| Total Float | LS β ES (or LF β EF) |
| Free Float | ES(next) β EF(current) |
| Crash Cost/Day | (CC β NC) Γ· (ND β CD) |
| Critical Path | Float = 0 AND longest path |
| PERT Expected | (O + 4M + P) Γ· 6 |
- Schedule behind + no budget β Fast Track
- Schedule behind + budget available β Crash
- Float = 0 β Critical Path
- Float negative β Schedule in trouble (overrun)
- Multiple paths same length β Multiple Critical Paths (more risky)
- Compress which path? β Always the Critical Path
- Crash which activity? β Cheapest one on CP first
- Resource leveling β May extend the CP
- Process Group: Planning
- Knowledge Area: Project Schedule Management
- Process: 6.5 Develop Schedule
- Inputs: Activity list, durations, sequence, resources, project calendar
- Tools & Techniques: CPM, Schedule Network Analysis, Resource Leveling, What-If Scenario Analysis
- Outputs: Project Schedule, Schedule Baseline, Schedule Data, Project Calendars
Click any keyword to review its definition quickly:
Leads and Lags modify the timing relationship between activities. They are applied to dependency relationships and directly impact path durations β and therefore the critical path.
What is Lead?
A Lead is an acceleration β it allows a successor activity to start before its predecessor finishes. Lead is essentially negative lag. It is commonly used in fast tracking.
Activity A: "Install electrical conduit" (14 days). Activity B: "Pull wire through conduit" (8 days). Relationship: FS β 4 days lead. Wire-pulling can begin on the already-installed sections 4 days before conduit installation is fully done. Path = 14 β 4 + 8 = 18 days instead of 22. Saves 4 days on the critical path!
What is Lag?
A Lag is a mandatory wait β a delay intentionally inserted between the predecessor finishing and the successor starting. Lag always adds time to a path.
| Lag Type | Example | Effect on Path |
|---|---|---|
| FS + Lag | Paint walls; wait 2 days to dry; then hang art | Adds lag days to path |
| SS + Lag | B can start 3 days after A starts | Adds constraint; may affect CP |
| FF + Lag | B must finish 2 days after A finishes | May lengthen successor path |
| FS β Lead | B starts 3 days before A finishes | Shortens path (used in fast tracking) |
Impact of Leads & Lags on the Critical Path
- Lag on a CP activity lengthens the critical path β increases project duration
- Lead on a CP activity shortens the critical path β reduces project duration
- Lag on a non-critical activity may consume its float and make it critical
- Always re-run forward/backward pass after adding leads or lags
- Lag = wait time = adds to path duration
- Lead = overlap = subtracts from path duration
- Excessive leads create rework risk (like fast tracking)
- Lags often represent physical constraints (curing, drying, regulatory waiting periods)
Definition & Risk
A Near-Critical Path is a network path whose total float is very small (close to zero) β typically defined as paths with float β€ 10β20% of project duration. These paths can easily become critical if any activity on them is delayed.
Project has two paths: CP (AβCβDβE) = 20 days. Near-critical (AβBβDβE) = 18 days (float = 2). During execution, Activity B is delayed 3 days due to a vendor issue. Now Path AβBβDβE = 21 days β it becomes the NEW critical path! The original critical path is no longer critical. The PM must immediately shift focus to the formerly near-critical path.
Path Convergence Risk
Path Convergence occurs when multiple paths merge into a single activity (a merge point). This dramatically increases schedule risk at that activity β if ANY of the converging paths is delayed, the merge activity is delayed.
| Situation | Risk Level | PM Action |
|---|---|---|
| Single CP, no near-critical paths | LowβMedium | Focus on CP activities |
| Near-critical path β€ 2 days float | High | Monitor both paths; consider pre-emptive crashing |
| Multiple paths converge at one activity | Very High | Identify merge point; buffer or crash feeding paths |
| Multiple critical paths exist | Highest | Manage all CPs simultaneously; risk register update |
Critical Chain Method (CCM) was developed by Eliyahu Goldratt (Theory of Constraints) as an improvement over CPM. It addresses a key CPM weakness: individual activity padding hides true schedule risk.
The Core Problem CCM Solves
In CPM, people add hidden buffers to their individual activity estimates (Parkinson's Law β work expands to fill time). These buffers are then wasted because of the Student Syndrome (starting late because "I have plenty of time"). CCM removes this problem.
| Feature | CPM | CCM |
|---|---|---|
| Focus | Activity sequence (logical dependencies) | Activity sequence + resource constraints |
| Duration estimates | Includes safety/padding per activity | Uses aggressive (50%) estimates; removes padding |
| Buffer management | Float on individual activities | Project Buffer (end) + Feeding Buffers (merge points) |
| Critical path | Longest logical path (CPM) | Longest resource-constrained path (Critical Chain) |
| Safety | Distributed across activities | Consolidated at buffer points |
| PMBOK reference | 6.5 Develop Schedule | 6.5 Develop Schedule (alternative T&T) |
CPM estimate for Activity X = 10 days (includes 4 days of individual buffer). CCM removes the buffer: estimates X at 6 days. All removed buffers from all activities are consolidated into a Project Buffer at the end (e.g., 14 days). If a feeding path merges into the critical chain, a Feeding Buffer protects the critical chain from late non-critical deliveries. Result: same safety, more visible and managed buffer.
- CCM = CPM + resource constraints + buffer management
- Project Buffer protects the project end date
- Feeding Buffers protect merge points
- Resource Buffer = reminder alerts that a resource will soon be needed on the critical chain
- If exam asks "which considers resources when determining the critical path?" β CCM
CPM tells you the schedule sequence; EVM tells you schedule performance. Together they give the PM a complete picture of where the project stands and whether the critical path is at risk.
Key EVM Metrics on the Critical Path
SPI (Schedule Performance Index) = EV / PV [<1.0 = Behind, >1.0 = Ahead]
EAC (Estimate at Completion) = BAC / CPI [Cost-focused]
ETC (Estimate to Complete) = EAC β AC
| SPI Value | Meaning | CP Implication |
|---|---|---|
| SPI = 1.0 | On schedule | CP is on track |
| SPI > 1.0 (e.g. 1.15) | Ahead of schedule | CP activities completing early β may allow float |
| 0.8 β€ SPI < 1.0 | Slightly behind | CP activities slipping β monitor closely |
| SPI < 0.8 | Significantly behind | Immediate compression action required on CP |
Using EVM for CP Recovery Decisions
Week 6 of a 20-week project. Critical path activities show: PV = $80,000, EV = $64,000, AC = $70,000.
- SV = EV β PV = $64K β $80K = β$16,000 (behind schedule)
- SPI = EV / PV = 64/80 = 0.80 (doing only 80Β’ of work per $1 planned)
- CPI = EV / AC = 64/70 = 0.91 (also over budget)
PM Decision: SPI = 0.80 on critical path β project will be ~4 weeks late if nothing changes (20 weeks Γ 0.20 slip). Crashing is needed but CPI shows cost efficiency already low. Fast tracking is the better first step to recover schedule without additional spending.
- SV and SPI measure schedule performance but don't identify WHICH activities are late β that's what the CPM network shows
- Use CPM to identify WHERE to act; use EVM to measure HOW MUCH recovery is needed
- SPI approaching end of project loses reliability; CPM remains the authoritative schedule tool
- Negative SV + critical path slip = high-urgency situation requiring immediate CP compression
Hard Logic vs Soft Logic
| Type | Also Called | Definition | Can be Changed? | Example |
|---|---|---|---|---|
| Mandatory | Hard Logic | Physically or contractually required | β No | Can't test software before it's coded |
| Discretionary | Soft Logic / Preferred Logic | Best practice choice; not physically required | β Yes (for fast tracking) | PM chooses to inspect before next phase |
| External | β | Depends on something outside the project | β οΈ Limited | Regulatory approval before construction |
| Internal | β | Depends on something within the project | β Often yes | Team A finishes design before Team B builds |
Date Constraints on Activities
Schedule software allows PMs to impose date constraints on activities. These override the calculated ES/EF and LS/LF, and directly affect float and the critical path:
| Constraint Type | Meaning | Impact |
|---|---|---|
| As Soon As Possible (ASAP) | Default β start at earliest calculated date | No impact (default behavior) |
| As Late As Possible (ALAP) | Delay start as long as possible without delaying project | Uses up float intentionally |
| Start No Earlier Than (SNET) | Activity cannot start before a given date | May create lag; can affect CP |
| Finish No Later Than (FNLT) | Activity must finish by a given date | Can create negative float if tight |
| Must Start On (MSO) | Fixed start date | Eliminates float; high risk |
| Must Finish On (MFO) | Fixed finish date | May cause negative float |
- ASAP is the default in CPM (preferred β gives maximum scheduling flexibility)
- Imposed date constraints that conflict with the calculated schedule create negative float
- Mandatory dependencies are never changed for fast tracking β only discretionary ones can be overlapped
- External dependencies (regulatory, permits, vendor deliveries) are often the most schedule-critical and uncontrollable
A lane closure permit from IDOT can only be used starting March 1 (regulatory constraint = external dependency). The CPM shows the paving activity could technically start February 10. The SNET constraint of March 1 creates 18 days of lag, potentially consuming all float on that path and making it critical. The PM must account for this in the baseline schedule and may need to crash preceding activities to avoid cascading delay.
What-If Scenario Analysis
What-If Scenario Analysis evaluates how variations or disruptions affect the project schedule. The PM creates alternative scenarios by changing activity durations, adding delays, or removing dependencies β then observes the impact on the critical path.
- "What if the concrete delivery is delayed 5 days?" β Does it impact the CP?
- "What if we lose 2 inspectors for 1 week?" β Which paths are affected?
- "What if we remove Activity X's dependency on Y?" β Does it shorten the CP?
Monte Carlo Simulation
Monte Carlo Simulation runs thousands of schedule simulations using probability distributions for activity durations. Instead of one deterministic answer (like CPM), it produces a probability distribution of project end dates.
| Feature | CPM | Monte Carlo |
|---|---|---|
| Duration input | Single estimate | Probability distribution (min, most likely, max) |
| Output | One project end date | Probability curve (e.g., "80% chance done by Day X") |
| Critical Path | Fixed single path | Criticality Index β % of simulations an activity is on CP |
| Use case | Baseline planning | Risk analysis, contingency reserve calculation |
| PMBOK process | 6.5 Develop Schedule | 11.4 Perform Quantitative Risk Analysis |
- Monte Carlo = quantitative risk analysis; used to determine schedule contingency reserve
- CPM = deterministic; Monte Carlo = probabilistic
- If exam asks about "probability of completing by a date" β Monte Carlo
- If exam asks about "which activities determine project duration" β CPM
CPM principles are universal but manifest differently across industries. Understanding these industry-specific applications helps on scenario-based PMP exam questions.
| Industry | Typical CP Activities | Common Lags | Unique Challenges |
|---|---|---|---|
| ποΈ Heavy Construction (Bridge, Highway) | Foundation, structural steel, deck concrete, surfacing | Concrete cure (7β28 days), soil settlement | Weather delays, permit windows, utility conflicts, lane closure restrictions |
| π» Software/IT | Architecture design, core development, integration, UAT | Environment setup, regulatory review | Scope creep, technical debt, sprint-to-release alignment |
| π Pharmaceutical/R&D | Trial phases, regulatory submissions, manufacturing scale-up | FDA review periods (months to years) | Regulatory uncertainty; trials can invalidate entire paths |
| π Manufacturing | Tooling, first article, production line setup, QA | Material lead times, vendor certification | Supply chain disruptions; resource-constrained multi-project environments |
| π₯οΈ Shipbuilding/Aerospace | Hull/airframe, systems integration, testing campaigns | Classification society inspections | Extremely long lead items; safety-critical sequences |
Critical path for a bascule bridge rehabilitation: Mobilize (3d) β Deck removal (10d) β Structural steel inspection (5d) β Steel repairs (14d) β Deck formwork (8d) β Concrete pour (3d) β Cure (14d) β Waterproofing (4d) β Overlay (5d) β Punch list (3d) = 69 days. Key lags: concrete cure (mandatory 14-day lag), steel inspection hold point (can't pour until passed). Near-critical: electrical/mechanical bascule system work path (65 days, only 4 days float). PM must closely track both paths and pre-order long-lead steel replacement items during mobilization.
The PMP exam tests not just theory but practical judgment. Knowing what PMs do wrong β and the correct approach β is essential for scenario questions.
| # | Common Mistake | Why It's Wrong | Correct Approach |
|---|---|---|---|
| 1 | Only monitoring the critical path | Near-critical paths can overtake the CP with a small delay | Monitor all paths; flag near-critical paths in risk register |
| 2 | Crashing non-critical activities first | Does nothing to reduce project duration | Always crash the cheapest CP activity first |
| 3 | Ignoring resource constraints in CPM | Paper schedule may be impossible to execute | Apply resource leveling; use CCM if resource-critical |
| 4 | Not updating the schedule after changes | Baseline becomes stale; float calculations wrong | Update schedule with every approved change; re-run CPM |
| 5 | Treating float as free time for the PM | Float belongs to the project/path, not one activity | Float consumed by one activity removes it from all activities on that path |
| 6 | Fast tracking mandatory dependencies | Physically impossible or contractually prohibited | Only fast track discretionary (soft logic) dependencies |
| 7 | Forgetting lags in forward/backward pass | Incorrect ES/EF/LS/LF; wrong critical path identified | Always include lags in duration calculations |
| 8 | Assuming one critical path is permanent | CP changes with delays, resource leveling, compression | Re-run CPM analysis regularly throughout execution |
| 9 | Compressing only to meet a date without cost/risk analysis | May cause cost overrun or quality issues | Analyze crash cost vs. penalty cost; evaluate fast track risk |
| 10 | Not communicating CP to the team | Team members don't know which activities cannot be late | Share critical path with team; highlight CP activities in schedule |
- Float is a path resource β one activity using float affects the entire path's float
- The PM does NOT "own" float β it belongs to the project schedule
- Resource leveling always comes after CPM analysis; it modifies (usually extends) the CP
- When a scenario gives you multiple options to recover schedule β fast track first (no cost), then crash if needed
- A project can finish early but NEVER faster than the critical path allows
Your notes auto-save to this browser. Use this space for your personal CPM study notes.
β Saved!