Agile & Incremental Development: Models, TDD, Scrum, Kanban

TAKEAWAYS:

• Agile prioritizes customer collaboration, working software, and responding to change over rigid processes, using iterative cycles (sprints) of 2–4 weeks.
• Incremental delivery breaks projects into small, functional releases (e.g., Daraz’s phased feature rollouts) to gather early feedback and reduce risk.
• Test-Driven Development (TDD) follows the cycle Red-Green-Refactor, ensuring code meets requirements before writing production logic (used in Kathmandu’s traffic management systems).
• Scrum uses roles (Scrum Master, Product Owner), artifacts (backlog, sprint burndown), and ceremonies (daily standups, retrospectives) to structure Agile teams.
• Kanban visualizes workflow (e.g., Pathao’s order processing) with columns for To Do, In Progress, Done, limiting work-in-progress (WIP) to avoid bottlenecks.
• Agile’s advantages (flexibility, faster delivery) contrast with disadvantages (documentation gaps, team dependency) compared to Waterfall.

Core Concepts: Agile vs. Traditional Models

Agile methods emerged as a reaction to the Waterfall model’s rigidity (sequential phases: requirements → design → implementation → testing → maintenance). Agile embraces change, collaboration, and delivering small, usable increments of software frequently.

The Agile Manifesto (4 Values, 12 Principles)

Agile is guided by four core values (from the Agile Manifesto):

1. Individuals and interactions over processes and tools.
2. Working software over comprehensive documentation.
3. Customer collaboration over contract negotiation.
4. Responding to change over following a plan.

Visual: Agile vs. Waterfall

stateDiagram-v2
    [*] --> Waterfall: Sequential Phases
    Waterfall --> Requirements: Fixed
    Requirements --> Design: Locked
    Design --> Implementation: Rigid
    Implementation --> Testing: Late Feedback
    Testing --> Maintenance: Changes Hard
    Maintenance --> [*]

    [*] --> Agile: Iterative Cycles
    Agile --> Sprint 1: Increment 1
    Sprint 1 --> Feedback: Continuous
    Feedback --> Sprint 2: Increment 2
    Sprint 2 --> Feedback: Adaptive
    Feedback --> [*]

Why Agile?

• Real-world example: eSewa uses Agile to roll out features like eSewa Pay in small sprints. If a payment glitch is found in Sprint 2, the team fixes it immediately instead of waiting for a year-long Waterfall release.
• Ncell’s app updates follow Agile: new features (e.g., Ncell Recharge API) are tested with a subset of users before full deployment.

Incremental Development: Delivering in Pieces

Incremental development splits the project into small, functional modules delivered sequentially. Each increment builds on the previous one, adding new features while maintaining stability.

How It Works

1. Prioritize features (e.g., Daraz’s login system before recommendation engine).
2. Develop core functionality first (MVP: Minimum Viable Product).
3. Release early, gather feedback, and refine.
4. Repeat until all features are delivered.

Visual: Incremental Delivery Phases

flowchart TD
    A["Start"] --> B["Define MVP"]
    B --> C["Develop Core Features"]
    C --> D["Release Increment 1"]
    D --> E["Gather Feedback: Stakeholders"]
    E --> F["Analyze Feedback: Prioritize"]
    F --> G["Develop Next Increment"]
    G --> D

Worked Example: Pathao’s Order System

• Increment 1: Riders can accept orders; users can track rides (basic functionality).
• Increment 2: Add payment integration (Khalti/eSewa).
• Increment 3: Implement rating system and driver incentives.
• Benefit: Pathao identified a payment failure bug in Increment 2 and fixed it before scaling to 100,000 users.

Advantages of Incremental Development

Agile Methodologies: Scrum and Kanban

1. Scrum: The Sprint-Based Framework

Scrum organizes work into sprints (2–4 weeks) with fixed goals. Key components:

• Roles:
  • Product Owner: Defines what to build (prioritizes backlog).
  • Scrum Master: Removes obstacles (like a traffic cop for the team).
  • Development Team: Builds the increment.
• Artifacts:
  • Product Backlog: List of all desired features (prioritized).
  • Sprint Backlog: Selected tasks for the current sprint.
  • Increment: Shippable product at the end of each sprint.
• Ceremonies:
  • Sprint Planning: What to build in the sprint.
  • Daily Standup: 15-minute sync (3 questions: What did I do? What will I do? Blockers?).
  • Sprint Review: Demo the increment to stakeholders.
  • Retrospective: Reflect on what went well/what to improve.

Visual: Scrum Sprint Cycle

flowchart LR
    A["Sprint Planning"] --> B["Daily Standups"]
    B --> C["Development"]
    C --> D["Sprint Review"]
    D --> E["Retrospective"]
    E --> A

Real Example: NTC’s Digital Ticketing System

• Problem: NTC’s old ticketing system was slow and prone to errors.
• Solution: Used Scrum to develop a new system in 3-month sprints.
  • Sprint 1: Basic ticket booking for trains.
  • Sprint 2: Add payment gateway (Khalti integration).
  • Sprint 3: Mobile app for real-time updates.
• Result: Reduced ticketing errors by 40% and improved user satisfaction.

2. Kanban: Visual Workflow Management

Kanban focuses on visualizing work and limiting work-in-progress (WIP) to avoid bottlenecks. Key features:

• Board: Columns represent stages (To Do, In Progress, Done).
• Cards: Represent tasks (e.g., "Fix Daraz checkout bug").
• WIP Limits: Maximum tasks allowed in In Progress (e.g., 3).
• Metrics: Lead time, cycle time, throughput.

Visual: Kanban Board for a Bank’s Loan Processing System

flowchart TD
    A["To Do\n(5 tasks)"] -->|"Add Task"| B["In Progress\n(WIP: 2)\n1. Verify docs\n2. Run credit check"]
    B --> C["Done\n(3 tasks)"]
    B -->|"Blocked"| D["Blocked\n(1 task)\nWaiting for NABL approval"]
    D --> B

Real Example: NEPSE’s Trading Platform

• Challenge: High volatility in stock trades led to delays.
• Solution: Used Kanban to track order processing:
  • To Do: New trades waiting for validation.
  • In Progress: Trades being matched (WIP limit = 5).
  • Done: Executed trades.
• Result: Reduced trade execution time by 30%.

Comparison: Scrum vs. Kanban

Test-Driven Development (TDD): Write Tests First

TDD is a development approach where tests are written before the actual code. The cycle:

1. Red: Write a failing test for a new feature.
2. Green: Write minimal code to pass the test.
3. Refactor: Improve the code without breaking tests.

Visual: TDD Cycle

flowchart LR
    A["Write Failing Test"] --> B["Write Code to Pass"]
    B --> C["Refactor Code"]
    C --> A

Worked Example: Kathmandu Traffic Management System

• Problem: Traffic lights need to prioritize ambulances dynamically.
• TDD Steps:
  1. Red: Write a test for "If ambulance signal is red, turn green immediately."

     def test_ambulance_priority():
         traffic_light.ambulance_signal = True
         assert traffic_light.current_color == "green"
     

  2. Green: Write code to pass the test:

     class TrafficLight:
         def __init__(self):
             self.ambulance_signal = False
             self.current_color = "red"
     
         def update(self):
             if self.ambulance_signal:
                 self.current_color = "green"
     

  3. Refactor: Add edge cases (e.g., pedestrian signals).

Advantages of TDD

• Catches bugs early: Tests act as a safety net.
• Designs better code: Forces modular, testable functions.
• Documents requirements: Tests serve as executable specs.
• Reduces regression: New changes don’t break old features.

Disadvantages

• Steep learning curve: Requires discipline.
• Slower initial development: Writing tests takes time.
• Overhead for simple projects: Not suitable for one-off scripts.

In the Real World

1. eSewa’s Agile Transformation

   • Idea Used: Scrum + Incremental Delivery
   • How: eSewa’s team uses 2-week sprints to release features like:
     • eSewa Pay: Developed in 3 increments (login → payment → receipt).
     • Feedback Loop: After each sprint, users test the app, and the team fixes issues (e.g., failed transactions in Sprint 2).
   • Impact: Reduced app crashes by 50% and increased user trust.

2. Daraz’s Kanban for Order Fulfillment

   • Idea Used: Kanban Board with WIP Limits
   • How: Daraz’s warehouse uses a Kanban board to track orders:
     • To Do: 100 pending orders.
     • In Progress: Max 20 orders (WIP limit).
     • Done: 50 shipped orders.
   • Result: Faster order processing and 30% reduction in delays.

3. Ncell’s TDD for App Stability

   • Idea Used: Test-Driven Development
   • How: Ncell’s team writes tests before adding new features (e.g., Ncell Recharge API):
     • Test: "If user enters wrong PIN, show error and retry option."
     • Code: Implements the logic, then refactors.
   • Outcome: Fewer crashes during Diwali sale traffic spikes.

Exam Tip: How to Score Full Marks

1. Diagrams Are Mandatory
   • Always draw neat labeled diagrams for:
     • Agile vs. Waterfall (state diagram).
     • Scrum sprint cycle (flowchart).
     • Kanban board (flowchart with WIP limits).
   • Example: For "Explain incremental delivery," include a 3-phase flowchart (MVP → Increment 1 → Increment 2).

2. Link Theory to Real Examples

   • Scrum: Mention eSewa’s sprints or NTC’s digital ticketing.
   • Kanban: Use Daraz’s order tracking or NEPSE’s trading.
   • TDD: Refer to Ncell’s app stability or traffic light systems.

3. Compare Methods in Tables

   • For "Advantages of Agile," use a 2-column table (Pros vs. Cons).
   • For "Scrum vs. Kanban," highlight roles, WIP limits, and use cases.

4. Define Key Terms Precisely

   • Sprint: "A time-boxed iteration (2–4 weeks) in Scrum to deliver a potentially shippable increment."
   • WIP Limit: "Maximum number of tasks allowed in a Kanban stage to prevent bottlenecks."

5. Avoid Vague Statements

   • ❌ "Agile is flexible." → ✅ "Agile embraces change through iterative sprints, unlike Waterfall’s fixed phases."

A physical Kanban board with WIP limits (e.g., In Progress: Max 3) and task cards. (Image: Bossarro, CC BY-SA 4.0, via Wikimedia Commons)