Project Planning & Scheduling: Methods, CPM, PERT, Gantt, and Resource Allocation

TAKEAWAYS:

• Project planning breaks work into tasks (WBS), estimates durations, and defines dependencies to create a roadmap.
• Critical Path Method (CPM) identifies the longest task sequence (critical path) that determines project completion time.
• Gantt charts visualize task timelines, dependencies, and resource allocation in a single timeline view.
• PERT combines optimistic/pessimistic estimates with probability for uncertain task durations.
• Resource leveling balances workloads to avoid bottlenecks, while crashing adds costs to shorten schedules.
• Software-specific scheduling must account for iterative development, testing cycles, and stakeholder reviews.

Core Concepts: Definitions and Workflow

1. Project Planning Process

Project planning transforms vague goals into actionable steps. It involves:

• Work Breakdown Structure (WBS): Decomposing the project into smaller, manageable tasks.
• Task Estimation: Assigning durations, costs, and resources to each task.
• Dependency Mapping: Identifying task sequences (e.g., "Design must precede coding").
• Scheduling: Assigning start/end dates and sequencing tasks.

flowchart TD
    A["Project Goal"] --> B["Work Breakdown Structure (WBS)"]
    B --> C["Task Estimation\n(Duration, Cost, Resources)"]
    C --> D["Dependency Mapping\n(Finish-to-Start, Start-to-Start)"]
    D --> E["Scheduling\n(Gantt/CPM)"]
    E --> F["Resource Allocation\n(Leveling/Crashing)"]
    F --> G["Monitoring & Control"]

2. Key Scheduling Methods

Why CPM/PERT Matter in Software: Software projects often have uncertain durations (e.g., debugging, API integrations) and interdependent tasks (e.g., UI design → backend → testing). CPM/PERT help prioritize tasks that directly impact delivery.

Deep Dive: Critical Path Method (CPM)

How CPM Works

1. List Tasks and Dependencies:

   • Example: Building a mobile app for eSewa (Nepal’s digital payment system).
     • Task A: "Design UI/UX" (3 weeks)
     • Task B: "Develop backend API" (4 weeks, depends on A)
     • Task C: "Integrate payment gateway" (2 weeks, depends on B)
     • Task D: "Testing" (2 weeks, depends on C)
     • Task E: "Deployment" (1 week, depends on D)

2. Draw the Network Diagram:

   graph LR
     A["Design UI/UX\n3w"] --> B["Develop Backend\n4w"]
     B --> C["Integrate Payment\n2w"]
     C --> D["Testing\n2w"]
     D --> E["Deployment\n1w"]

   • Forward Pass: Calculate Early Start (ES) and Early Finish (EF).
     • ES(A) = 0, EF(A) = 3
     • ES(B) = EF(A) = 3, EF(B) = 7
     • ES(C) = EF(B) = 7, EF(C) = 9
     • ES(D) = EF(C) = 9, EF(D) = 11
     • ES(E) = EF(D) = 11, EF(E) = 12

3. Backward Pass: Calculate Late Start (LS) and Late Finish (LF) (assuming project end = 12 weeks).

   • LF(E) = 12, LS(E) = 11
   • LF(D) = 11, LS(D) = 9
   • LF(C) = 9, LS(C) = 7
   • LF(B) = 7, LS(B) = 3
   • LF(A) = 3, LS(A) = 0

4. Slack Time Calculation:

   • Slack = LS – ES (or LF – EF).
   • Task A: Slack = 0 (critical)
   • Task B: Slack = 0 (critical)
   • Task C: Slack = 0 (critical)
   • Task D: Slack = 0 (critical)
   • Task E: Slack = 0 (critical)
   • Critical Path: A → B → C → D → E (total duration = 12 weeks).

Real-World Example:

• Pathao’s Ride-Hailing App:
  • Critical Path: "Driver App Development" → "Dispatcher Server" → "Payment Integration" → "Beta Testing".
  • Delay in payment integration (Task C) would directly delay the entire launch, as it has zero slack.

CPM vs. PERT: When to Use Which

Worked Example: PERT for a Daraz Order Fulfillment System

• Task: "Develop Order Tracking Module"
  • Optimistic (O) = 2 weeks
  • Pessimistic (P) = 6 weeks
  • Most Likely (M) = 4 weeks
• Expected Duration (Te): $Te=(2+4\ast 4+6)/6=(2+16+6)/6=24/6=4$ weeks.

Scheduling Tools and Trade-offs

1. Gantt Charts: Visualizing the Plan

gantt
    title eSewa Mobile App Development
    dateFormat  W
    section Phase 1: Planning
    A[Design UI/UX] :a1, 3, 0
    B[Backend API] :after a1, 4, 0
    section Phase 2: Integration
    C[Payment Gateway] :after b1, 2, 0
    D[Testing] :after c1, 2, 0
    E[Deployment] :after d1, 1, 0

Key Features:

• Baseline: Original plan (blue).
• Actual Progress: Green bars (updated weekly).
• Milestones: Red diamonds (e.g., "Payment Gateway Ready").

2. Resource Allocation: Leveling and Crashing

• Resource Leveling: Smooths out workloads to avoid bottlenecks.
  • Example: If 3 developers are assigned to Task B (4 weeks), but only 2 are available, the task may take 6 weeks (slack increases).
• Crashing: Adds resources (e.g., hiring freelancers) to shorten the critical path.
  • Cost: Higher wages, but saves time.
  • Example: NTC’s Fiber Optic Expansion crashed the "Cable Laying" task by hiring extra crews, reducing duration from 12 to 8 weeks at a cost of ₹50M.

Trade-off Table:

Software-Specific Scheduling Challenges

1. Iterative Development:

   • Unlike waterfall, Agile projects have sprint-based schedules (e.g., 2-week cycles).
   • CPM Adaptation: Critical path may change every sprint (e.g., new bugs discovered in testing).

2. Testing and Retesting:

   • Example: A bank’s loan processing system may require 3 rounds of testing before deployment.
   • Schedule Impact: Adds buffer time (e.g., +20% to the critical path).

3. Stakeholder Reviews:

   • Example: NEPSE’s trading platform must align with SEBON’s regulatory reviews.
   • Dependency: "Regulatory Approval" is a mandatory milestone before launch.

Visualizing Agile Scheduling:

stateDiagram-v2
    [*] --> Sprint1: "Backlog Refinement"
    Sprint1 --> Sprint2: "Development\n(3 tasks)"
    Sprint2 --> Sprint3: "Testing\n(2 tasks)"
    Sprint3 --> Sprint4: "Review\n(1 task)"
    Sprint4 --> [*]
    note right of Sprint2
        Critical Path:
        Task A → Task B → Task C
    end note

Exam Tip: How to Score Full Marks

1. For CPM/PERT Questions:

   • Always show forward/backward pass calculations (even if not asked).
   • Highlight the critical path in bold and explain why it’s critical.
   • Example answer structure:

     Step 1: List tasks with durations/dependencies.
     Step 2: Draw network diagram (use Mermaid in exams if allowed).
     Step 3: Calculate ES/EF and LS/LF for each task.
     Step 4: Identify critical path (slack = 0).
     Step 5: Conclude with project duration and risk areas.
     

2. For Gantt Charts:

   • Describe 3 key dependencies and how they affect the timeline.
   • Mention one resource constraint (e.g., "Only 1 QA engineer available").

3. For Real-World Applications:

   • Tie answers to Nepali companies (e.g., "Khalti’s payment gateway integration follows CPM to ensure zero slack in transaction processing").
   • Use numbers (e.g., "A 4-week delay in Daraz’s inventory system would shift the critical path by 4 weeks").

4. Common Pitfalls to Avoid:

   • Forgetting to label the critical path.
   • Ignoring slack time in non-critical tasks.
   • Not explaining trade-offs (e.g., "Crashing reduces time but increases cost").

In the Real World

1. eSewa’s Digital Payment System

   • Idea Used: Critical Path Method (CPM)
   • How: The team mapped dependencies like:
     • "User Authentication" → "Transaction API" → "SMS Notification" → "Load Testing".
   • Impact: Ensured the payment gateway (a critical task with zero slack) was ready before the 2015 launch.

2. Pathao’s Ride-Hailing App

   • Idea Used: Resource Leveling + PERT
   • How: Used PERT for uncertain tasks like "Driver App Development" (O=6w, M=8w, P=12w) and leveled resources by assigning UI/UX designers to both iOS and Android simultaneously.
   • Impact: Reduced app development time by 30% without overloading the team.

3. NTC’s Fiber Optic Expansion

   • Idea Used: Crashing
   • How: Originally, "Cable Laying" was estimated at 12 weeks. NTC crash-hired 500 workers and used overtime to reduce it to 8 weeks.
   • Cost: ₹50 million extra, but saved ₹200 million in delayed revenue.

4. Nepal Rastra Bank’s Core Banking System

   • Idea Used: Gantt Charts + Milestones
   • How: Used Gantt charts to track:
     • "Regulatory Compliance" (must finish before testing).
     • "Data Migration" (depends on old system shutdown).
   • Impact: Avoided a 6-month delay by identifying the compliance milestone as critical.