PadhaikoAll subjects

Project Time Management

ICT Project Management (ENCT 412)

Open in the Padhaiko app

7.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).

Definition

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

  1. 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).
  2. 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
  3. 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

  1. 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).
  2. 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).
  3. External Dependencies: Links to factors outside the project team's control (e.g., waiting for third-party payment gateway sandbox approval or hardware delivery).
  4. Internal Dependencies: Precedence relationships between project activities under the team's control.

Precedence Relationships, Leads, and Lags

Definition

Four Logical Precedence Relationships

In network scheduling, any predecessor and successor can be linked by one of four logical relationships:

  1. Finish-to-Start (FS): cannot start until has finished (most common in ICT, of links). Example: Database deployment (A) Data migration (B).
  2. Start-to-Start (SS): cannot start until has started. Example: Coding module (A) starts Writing unit tests (B) starts in parallel.
  3. Finish-to-Finish (FF): cannot finish until has finished. Example: Writing system code (A) finishes Completing user documentation (B) finishes.
  4. 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.

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:

  1. 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).
  2. 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.
AspectPrecedence Diagramming Method (PDM / AON)Arrow Diagramming Method (ADM / AOA)
Activity RepresentationBox / NodeDirected Arrow
Event / Dependency RepresentationDirected ArrowCircle / Node (Event)
Supported RelationshipsFS, SS, FF, SF (all four)FS only
Dummy Activities Needed?NeverFrequently required (dashed arrows, duration)
Leads & LagsDirectly labeled on arrowsDifficult to represent cleanly
Industry AdoptionModern standard (MS Project, Primavera)Legacy / classical PERT textbooks
PDM Node Box Layout vs. ADM Dummy ActivityText
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.

Definition

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

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

  1. Schedule from Realistic Logic & Resources: Connect every task (except start/end) to a predecessor and successor, respecting resource availability.
  2. Use Milestones as Governance Gates: Place zero-duration milestones at phase transitions, API freezes, and client demos to track major progress without clutter.
  3. 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)

Definition

CPM Parameters: Forward Pass, Backward Pass, and Float

Using the standard zero-based start convention (project starts at ), for each activity of duration :

  1. Forward Pass (computes Earliest dates, left right):
    • Start activities (no predecessors): .
    • Other activities: .
    • Early Finish: .
    • Project Duration: .
  2. Backward Pass (computes Latest dates, right left):
    • Terminal activities (no successors): .
    • Other activities: .
    • Late Start: .
  3. Schedule Slack (Float):
    • Total Float (): Maximum time an activity can be delayed without delaying the project completion date:
  1. 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:

  1. Identifies the Critical Chain: The longest sequence of both task dependencies and shared resource dependencies.
  2. 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).
  3. 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.

Sample ICT Project Gantt Chart (Weeks 1–10)Text
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:

Schedule Compression and Resource Optimization Techniques
TechniqueHow It WorksTrade-Off / Risk
CrashingAdds extra resources (overtime, more engineers) to critical path activities with the lowest crash cost per dayIncreases project cost; diminishing returns (Brooks's Law)
Fast TrackingExecutes normally sequential critical activities in parallel (overlapping coding and testing)Increases rework and quality risk without necessarily adding upfront cost
Resource LevelingDelays non-critical (or even critical) tasks to eliminate resource over-allocation peaksMay extend the critical path and project finish date
Resource SmoothingAdjusts activities only within their available float to smooth resource usageNever changes the critical path or project finish date

For Crashing, the unit crash cost (cost slope) of an activity is:


Worked Out Examples

Example 7.1

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 Table for ICT Release Schedule
ActivityDescriptionDuration (days)Immediate Predecessors
ARequirements Sign-off—
BUI/UX WireframesA
CDatabase ArchitectureA
DBackend MicroservicesC
EFrontend–API IntegrationB, D
FSecurity & Load TestingD
GDeployment & UATE, F

Using the -based convention ( at start):

  1. Draw the PDM (Activity-on-Node) network structure.
  2. Perform the Forward Pass () and Backward Pass ().
  3. Compute Total Float () and Free Float () for every activity, and identify the Critical Path and minimum project duration.

Drawing the PDM Network Diagram:

PDM Network Diagram for Activities A–GText
            +--- 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): , .
Complete CPM Schedule and Float Table
ActivityDurationESEFLSLFTotal Float (TF)Free Float (FF)Critical?
AYes
BNo
CYes
DYes
EYes
FNo
GYes
Answer:
  • Critical Path: ( on all five activities).
  • Minimum Project Duration: .
  • Non-critical Floats: has ; has .
Example 7.2

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):

  1. Compute the expected duration (), standard deviation (), and variance () for each task.
  2. Find the expected project duration () and project standard deviation ().
  3. 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, .

Answer:
  1. Task : Task 1 , Task 2 , Task 3 .
  2. Expected project duration , project standard deviation .
  3. Probability of finishing within (): .
Example 7.3

7.3

Time–Cost Trade-Off (Crashing a Project Network): An ICT security audit network has four activities:

Normal vs. Crash Data for Security Audit Network
ActivityPredecessorNormal Time (days)Normal Cost ()Crash Time (days)Crash Cost ()
A—
BA
CA
DB, C
  1. Compute the crash cost per day (cost slope) and maximum crashable days for each activity.
  2. Find the normal project duration, critical path, and normal direct cost.
  3. 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 :

Answer:
  1. Crash slopes: , , , .
  2. Normal duration (Critical Path ), normal direct cost .
  3. Crash by and by to reach at minimum total direct cost of .

Exercises

Practice Exercises — Project Time Management

Question 1

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:

  1. Finish-to-Start (FS): Successor starts after predecessor finishes.
  2. Start-to-Start (SS): Successor starts after predecessor starts.
  3. Finish-to-Finish (FF): Successor finishes after predecessor finishes.
  4. Start-to-Finish (SF): Successor finishes after predecessor starts.
Answer:

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.

Question 2

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.
Answer:

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).

Question 3

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.
Answer:

(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.

Question 4

Find the Critical Path, minimum project duration, and Total Float for every activity in the following software project (-based start):

Forward Pass ( at start):

  • A:
  • B:
  • C:
  • D:
  • E:
  • F:

Minimum project duration .

Backward Pass and Total Float ():

  • F:
  • D:
  • E:
  • B:
  • C:
  • A:
Answer:
  • Critical Path: (duration ).
  • Total Floats: , , , ; , .
Question 5

A critical path contains three sequential PERT activities with in days:

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:

Answer:

(a) : ; : ; : . (b) Expected duration , project standard deviation .

← Project Scope ManagementProject Cost Management →