Project Time Management
Open in the Padhaiko app7.1 Activity definition, decomposition of activities, activity attributes
In Chapter 6, the WBS broke project scope into tangible Work Packages (nouns). Activity Definition bridges scope to time by breaking each work package into executable Schedule Activities (action-oriented tasks).
Define Activities and Decomposition
Define Activities is the Planning process of identifying and documenting the specific actions to be performed to produce the project deliverables.
Decomposition in Time Management subdivides WBS Work Packages into smaller, measurable Schedule Activities that serve as the basis for estimating, scheduling, executing, monitoring, and controlling project work.
Key Outputs of Activity Definition
- Activity List: A comprehensive table listing every schedule activity required on the project, including an Activity Identifier and a clear Scope of Work Description (e.g.,
A104: Implement OAuth2 JWT token middleware). - Activity Attributes: Detailed metadata that expands over time via rolling-wave planning:
- Activity ID, WBS ID, and Activity Name
- Predecessor and successor relationships (with leads/lags)
- Required resources, skills, and effort hours
- Imposed dates/constraints (e.g., Start No Earlier Than), geographic location, and responsible owner
- Milestone List: A list of significant, zero-duration events or checkpoints in the project (e.g., System Architecture Freeze, Beta Release, Production Go-Live), classified as mandatory (contractual) or optional (internal management checkpoints).
7.2 Activity sequencing, precedence relationship, network diagram, precedence diagram method, arrow diagramming method
Once activities are defined, Sequence Activities determines the logical order of work to achieve maximum efficiency given project constraints.
Dependency Types
- Mandatory Dependencies (Hard Logic): Inherent to the nature of the work or required by contract (e.g., you cannot run integration tests before writing the API code).
- Discretionary Dependencies (Preferred / Soft Logic): Established based on team best practices or preferences (e.g., choosing to build the Admin UI before the Analytics Dashboard, even though both could run in parallel).
- External Dependencies: Links to factors outside the project team's control (e.g., waiting for third-party payment gateway sandbox approval or hardware delivery).
- Internal Dependencies: Precedence relationships between project activities under the team's control.
Precedence Relationships, Leads, and Lags
Four Logical Precedence Relationships
In network scheduling, any predecessor and successor can be linked by one of four logical relationships:
- Finish-to-Start (FS): cannot start until has finished (most common in ICT, of links). Example: Database deployment (A) Data migration (B).
- Start-to-Start (SS): cannot start until has started. Example: Coding module (A) starts Writing unit tests (B) starts in parallel.
- Finish-to-Finish (FF): cannot finish until has finished. Example: Writing system code (A) finishes Completing user documentation (B) finishes.
- Start-to-Finish (SF): cannot finish until has started (rare). Example: New cloud billing server goes live (A) starts Legacy billing server shutdown (B) finishes.
- Lead (): Acceleration of a successor activity relative to its predecessor (e.g., means can start before finishes).
- Lag (): Mandatory waiting time added between predecessor and successor (e.g., wait for DNS propagation or security audit sign-off before go-live).
Network Diagrams: PDM vs. ADM
A Project Schedule Network Diagram is a graphical representation of the logical relationships (dependencies) among schedule activities. Two classical diagramming notations are used:
- Precedence Diagramming Method (PDM / Activity-on-Node, AON):
- Nodes (boxes) represent activities; arrows represent dependencies.
- Supports all four relationships (FS, SS, FF, SF) as well as leads and lags directly.
- Requires no dummy activities and is the standard used by modern tools (MS Project, Primavera, Jira).
- Arrow Diagramming Method (ADM / Activity-on-Arrow, AOA):
- Arrows represent activities; circles/nodes represent events (start/finish points).
- Supports only Finish-to-Start (FS) relationships directly.
- Often requires dummy activities (dashed arrows of zero duration and zero resource cost) to preserve unique
(start-node, end-node)activity identifiers or represent parallel dependencies without false precedence.
| Aspect | Precedence Diagramming Method (PDM / AON) | Arrow Diagramming Method (ADM / AOA) |
|---|---|---|
| Activity Representation | Box / Node | Directed Arrow |
| Event / Dependency Representation | Directed Arrow | Circle / Node (Event) |
| Supported Relationships | FS, SS, FF, SF (all four) | FS only |
| Dummy Activities Needed? | Never | Frequently required (dashed arrows, duration) |
| Leads & Lags | Directly labeled on arrows | Difficult to represent cleanly |
| Industry Adoption | Modern standard (MS Project, Primavera) | Legacy / classical PERT textbooks |
PDM (AON) Standard Activity Box: ADM (AOA) Dummy Activity Example:
+------+----------+------+ (1) ---A---> (2) ---C---> (4)
| ES | ID | EF | ^
+------+----------+------+ | (dummy, d=0)
| LS | Duration | LF | (1) ---B---> (3) ---D---> (4)
+------+----------+------+ Here D depends on BOTH A and B;
Total Float (TF) = LS - ES = LF - EF C depends ONLY on A.7.3 Activity resources estimating, determining resource requirements
Before activity durations can be calculated accurately, the team must estimate what resources (and how many units of each) are needed to perform each activity.
Estimate Activity Resources
Estimate Activity Resources is the Planning process of estimating the type and quantities of material, human resources (skills and headcount), equipment (servers, test devices), or cloud/software supplies required to perform each schedule activity.
Determining Resource Requirements
- Key Inputs: Activity List, Activity Attributes, Resource Calendars (when engineers, QA labs, or specialists are actually available, accounting for holidays/shifts), Enterprise Environmental Factors, and OPAs.
- Tools & Techniques:
- Expert Judgment: Consulting senior engineers or functional leads who executed similar builds.
- Alternatives Analysis: Evaluating trade-offs (e.g., 2 senior developers vs. 4 junior developers, or buying a cloud SaaS vs. building in-house).
- Published Estimating Data: Industry benchmarks for developer productivity, server setup hours, or vendor quotes.
- Bottom-Up Estimating: Summing detailed resource estimates for sub-tasks up to the activity and work-package level.
- Project Management Software: Tracking resource pools, skills matrices, and over-allocation alerts.
- Key Outputs:
- Activity Resource Requirements: Exact resource types and quantities per activity (e.g., 2 Backend Engineers + 1 Staging Cluster for 5 days).
- Resource Breakdown Structure (RBS): A hierarchical representation of resources by category and type (e.g., Human Engineering Backend / Frontend / QA).
Bridge to Schedule Development: Three-Point (PERT) Duration Estimating
Once resources are known, activity durations are estimated using Analogous, Parametric, or PERT Three-Point Estimation to capture uncertainty:
where = Optimistic time, = Most Likely time, and = Pessimistic time. For independent sequential activities along the critical path:
7.4 Schedule development and control, principles of scheduling, milestones, forward pass, backward pass, critical path method (CPM), critical chain technique, Gantt chart, schedule control
Develop Schedule analyzes activity sequences, durations, resource requirements, and schedule constraints to create the Schedule Model and approved Schedule Baseline.
Principles of Effective Scheduling & Milestones
- Schedule from Realistic Logic & Resources: Connect every task (except start/end) to a predecessor and successor, respecting resource availability.
- Use Milestones as Governance Gates: Place zero-duration milestones at phase transitions, API freezes, and client demos to track major progress without clutter.
- Separate Baseline from Working Forecast: Freeze the approved Schedule Baseline to measure variance objectively while updating forecast dates during execution.
Forward Pass, Backward Pass, and Critical Path Method (CPM)
CPM Parameters: Forward Pass, Backward Pass, and Float
Using the standard zero-based start convention (project starts at ), for each activity of duration :
- Forward Pass (computes Earliest dates, left right):
- Start activities (no predecessors): .
- Other activities: .
- Early Finish: .
- Project Duration: .
- Backward Pass (computes Latest dates, right left):
- Terminal activities (no successors): .
- Other activities: .
- Late Start: .
- Schedule Slack (Float):
- Total Float (): Maximum time an activity can be delayed without delaying the project completion date:
- Free Float (): Maximum time an activity can be delayed without delaying the Early Start of any immediate successor:
- Critical Path: The longest-duration path (or paths) through the network, determining the shortest possible project completion time. Activities on the critical path have zero Total Float ()—any delay on a critical activity directly delays the entire project.
Critical Chain Technique (CCPM)
Proposed by Eliyahu Goldratt (Theory of Constraints), Critical Chain Project Management (CCPM) modifies CPM to account for resource constraints and human behavioral padding:
- Identifies the Critical Chain: The longest sequence of both task dependencies and shared resource dependencies.
- Removes Individual Task Buffers: Cuts hidden safety padding from individual activities (countering Student Syndrome—starting late—and Parkinson's Law—work expanding to fill available time).
- Pools Buffers Strategically:
- Project Buffer: Placed at the end of the critical chain to protect the final delivery date.
- Feeding Buffers: Placed where non-critical paths feed into the critical chain so delays on side paths do not stall critical work.
- Resource Buffers: Early-warning alerts notifying critical shared specialists ahead of when their task begins.
Gantt Chart
A Gantt Chart plots schedule activities as horizontal bars against a calendar timeline, making start/end dates, parallel overlap, milestones (), and baseline-vs-actual tracking immediately readable for stakeholders.
Activity | W1 W2 W3 W4 W5 W6 W7 W8 W9 W10
----------------------+----------------------------------------
1. Requirements [A] | [======]
* Milestone: Spec | <>
2. UI Design [B] | [====]
3. DB Schema [C] | [========]
4. Backend API [D] | [==========]
5. Integration [E] | [======]
6. Go-Live [M] | <>Schedule Control & Optimization Techniques
Schedule Control monitors actual progress against the Schedule Baseline, identifies variances, and applies corrective techniques when behind schedule:
| Technique | How It Works | Trade-Off / Risk |
|---|---|---|
| Crashing | Adds extra resources (overtime, more engineers) to critical path activities with the lowest crash cost per day | Increases project cost; diminishing returns (Brooks's Law) |
| Fast Tracking | Executes normally sequential critical activities in parallel (overlapping coding and testing) | Increases rework and quality risk without necessarily adding upfront cost |
| Resource Leveling | Delays non-critical (or even critical) tasks to eliminate resource over-allocation peaks | May extend the critical path and project finish date |
| Resource Smoothing | Adjusts activities only within their available float to smooth resource usage | Never changes the critical path or project finish date |
For Crashing, the unit crash cost (cost slope) of an activity is:
Worked Out Examples
7.1
Full CPM Forward Pass, Backward Pass, Float, and Critical Path: An ICT software release consists of seven activities with durations (in days) and immediate predecessors as follows:
| Activity | Description | Duration (days) | Immediate Predecessors |
|---|---|---|---|
| A | Requirements Sign-off | — | |
| B | UI/UX Wireframes | A | |
| C | Database Architecture | A | |
| D | Backend Microservices | C | |
| E | Frontend–API Integration | B, D | |
| F | Security & Load Testing | D | |
| G | Deployment & UAT | E, F |
Using the -based convention ( at start):
- Draw the PDM (Activity-on-Node) network structure.
- Perform the Forward Pass () and Backward Pass ().
- Compute Total Float () and Free Float () for every activity, and identify the Critical Path and minimum project duration.
Drawing the PDM Network Diagram:
+--- B (3) ----------------+
/ \
Start --> A (4) +--> E (4) --+
\ / \
+--- C (5) ---> D (6) -----+ +--> G (2) --> End
\ /
+--> F (3) --------+Forward Pass (left right, ):
- A: , .
- B: , .
- C: , .
- D: , .
- E (predecessors B, D): , .
- F (predecessor D): , .
- G (predecessors E, F): , .
Minimum Project Duration .
Backward Pass (right left, ) and Float Calculation:
- G: , .
- E (successor G): , .
- F (successor G): , .
- D (successors E, F): , .
- B (successor E): , .
- C (successor D): , .
- A (successors B, C): , .
| Activity | Duration | ES | EF | LS | LF | Total Float (TF) | Free Float (FF) | Critical? |
|---|---|---|---|---|---|---|---|---|
| A | Yes | |||||||
| B | No | |||||||
| C | Yes | |||||||
| D | Yes | |||||||
| E | Yes | |||||||
| F | No | |||||||
| G | Yes |
- Critical Path: ( on all five activities).
- Minimum Project Duration: .
- Non-critical Floats: has ; has .
7.2
PERT Three-Point Duration Estimation & Completion Probability: A critical path in a cloud migration project consists of three sequential activities with optimistic (), most likely (), and pessimistic () durations (in days):
- Task 1 (Schema Conversion):
- Task 2 (Data Replication):
- Task 3 (Cutover Validation):
- Compute the expected duration (), standard deviation (), and variance () for each task.
- Find the expected project duration () and project standard deviation ().
- Calculate the probability of completing the critical path within (given ).
Computing expected duration and variance per task:
Summing expected durations and variances along the critical path:
Computing the -score and probability for target :
From the standard normal distribution table, .
- Task : Task 1 , Task 2 , Task 3 .
- Expected project duration , project standard deviation .
- Probability of finishing within (): .
7.3
Time–Cost Trade-Off (Crashing a Project Network): An ICT security audit network has four activities:
| Activity | Predecessor | Normal Time (days) | Normal Cost () | Crash Time (days) | Crash Cost () |
|---|---|---|---|---|---|
| A | — | ||||
| B | A | ||||
| C | A | ||||
| D | B, C |
- Compute the crash cost per day (cost slope) and maximum crashable days for each activity.
- Find the normal project duration, critical path, and normal direct cost.
- Crash the network step by step at minimum additional cost to reduce the project duration to , stating the final total direct cost.
Computing crash cost slopes and normal network paths:
Normal paths:
- (Critical Path)
Normal direct cost .
Crashing from down to :
- 13 12 days: Only is critical. Cheapest critical activity is (). Crash by (). Paths: , . Added cost .
- 12 11 days: Only is critical; still has left at . Crash by (). Paths: , (both paths are now critical!). Added cost .
- 11 10 days: Both parallel paths must be shortened simultaneously. Since is at its crash limit (), the candidates covering both paths are A alone () or D alone (). Cheapest is by (). Paths: , . Added cost .
Total direct cost at :
- Crash slopes: , , , .
- Normal duration (Critical Path ), normal direct cost .
- Crash by and by to reach at minimum total direct cost of .
Exercises
Practice Exercises — Project Time Management
Compare the Precedence Diagramming Method (PDM / AON) and the Arrow Diagramming Method (ADM / AOA). Explain the purpose of a dummy activity in ADM and list the four precedence relationships supported by PDM.
PDM vs. ADM and dummy activities:
- PDM (AON) places activities on nodes (boxes) and dependencies on arrows, supporting all four relationships (FS, SS, FF, SF) plus leads/lags with no dummy activities.
- ADM (AOA) places activities on arrows and events on nodes (circles), supporting only FS relationships. A dummy activity (dashed arrow, zero duration, zero resources) is used in ADM when two parallel activities share the same start and end nodes or when a successor depends on a subset of upstream activities without creating false precedence.
Four precedence relationships:
- Finish-to-Start (FS): Successor starts after predecessor finishes.
- Start-to-Start (SS): Successor starts after predecessor starts.
- Finish-to-Finish (FF): Successor finishes after predecessor finishes.
- Start-to-Finish (SF): Successor finishes after predecessor starts.
PDM represents activities as nodes and supports FS, SS, FF, and SF directly without dummy tasks, whereas ADM represents activities as arrows, supports FS only, and requires zero-duration dummy activities to represent shared/split precedence cleanly.
Explain the Critical Chain Project Management (CCPM) technique and how it differs from the traditional Critical Path Method (CPM). Define Project Buffer, Feeding Buffer, and Resource Buffer.
CCPM vs. CPM: Traditional CPM assumes unlimited resources and keeps hidden safety padding inside every task estimate (which gets wasted by Student Syndrome and Parkinson's Law). CCPM builds a resource-constrained critical chain, strips individual task buffers to realistic -confidence durations, and pools safety at key points.
Three CCPM buffers:
- Project Buffer: Pooled time buffer placed at the end of the critical chain to protect the final project due date.
- Feeding Buffer: Placed where a non-critical chain merges into the critical chain so side-path delays do not interrupt critical tasks.
- Resource Buffer: Advance alert sent to critical shared resources before their critical-chain activity starts.
CCPM accounts for resource dependencies (unlike pure CPM), strips individual task padding, and protects schedule reliability using a Project Buffer (at project end), Feeding Buffers (at non-critical merges), and Resource Buffers (advance resource alerts).
Distinguish between: (a) Total Float and Free Float; (b) Crashing and Fast Tracking; (c) Resource Leveling and Resource Smoothing.
Three core Schedule Development & Control pairs:
- (a) Total Float vs. Free Float: Total Float () is how long an activity can slip without delaying the project finish date; Free Float () is how long it can slip without delaying any immediate successor's Early Start.
- (b) Crashing vs. Fast Tracking: Crashing adds resources/cost to critical activities to shorten duration (increases cost); Fast Tracking overlaps sequential critical activities in parallel (increases rework risk).
- (c) Resource Leveling vs. Resource Smoothing: Resource Leveling resolves over-allocation by shifting tasks even if it extends the critical path/finish date; Resource Smoothing adjusts tasks only within available float so the critical path and end date never change.
(a) Total Float delays no project end date; Free Float delays no immediate successor's ES. (b) Crashing trades higher cost for speed; Fast Tracking trades higher rework risk by overlapping tasks. (c) Leveling can extend the end date to fix over-allocation; Smoothing only uses existing float and preserves the end date.
Find the Critical Path, minimum project duration, and Total Float for every activity in the following software project (-based start):
- A (Plan, , Pred: —)
- B (API Dev, , Pred: A)
- C (UI Dev, , Pred: A)
- D (Integration, , Pred: B)
- E (Frontend Wiring, , Pred: C)
- F (UAT & Launch, , Pred: D, E)
Forward Pass ( at start):
- A:
- B:
- C:
- D:
- E:
- F:
Minimum project duration .
Backward Pass and Total Float ():
- F:
- D:
- E:
- B:
- C:
- A:
- Critical Path: (duration ).
- Total Floats: , , , ; , .
A critical path contains three sequential PERT activities with in days:
- X:
- Y:
- Z:
Calculate: (a) each activity's expected duration and variance ; (b) the expected critical path duration and project standard deviation .
Computing , , and for X, Y, and Z:
Computing total expected duration and project standard deviation:
(a) : ; : ; : . (b) Expected duration , project standard deviation .