Agile vs. Waterfall: Methodologies, Scrum, Kanban, XP & Quality Techniques

TAKEAWAYS:

• Waterfall is linear and rigid; Agile is iterative and flexible—choose based on project uncertainty and stakeholder needs.
• Scrum uses sprints, daily standups, and backlogs; Kanban visualizes workflow with WIP limits; XP emphasizes coding standards and pair programming.
• Quality techniques (reviews, testing, metrics) reduce defects early—critical for apps like eSewa where downtime costs money.
• RAD (Rapid Application Development) speeds up prototyping but risks scope creep; Spiral balances risk analysis with iteration.
• Real-world tie: Pathao’s driver app uses Kanban for real-time order tracking, while NTC’s billing system follows Waterfall for regulatory compliance.

1. Software Development Methodologies: The Big Picture

Software development methodologies are structured approaches to planning, designing, building, and delivering software. They define:

• Process flow (sequential vs. iterative)
• Roles (developers, testers, PMs)
• Deliverables (requirements, prototypes, code)
• Adaptability (rigid vs. flexible)

The 4 Core Methodologies

classDiagram
    class Methodology {
        +name: String
        +type: String ["Plan-driven", "Agile", "Hybrid"]
        +phases: String[]
        +bestFor: String
    }
    class Waterfall {
        +phases: ["Requirements", "Design", "Implementation", "Testing", "Deployment", "Maintenance"]
        +type: "Plan-driven"
    }
    class Agile {
        +phaces: ["Iterative cycles", "Sprints", "Continuous feedback"]
        +type: "Agile"
    }
    class RAD {
        +phases: ["Requirements", "Prototyping", "Iterative development"]
        +type: "Agile (Fast-tracked)"
    }
    class Spiral {
        +phases: ["Risk analysis", "Iterative cycles", "Customer feedback"]
        +type: "Hybrid"
    }
    Methodology <|-- Waterfall
    Methodology <|-- Agile
    Methodology <|-- RAD
    Methodology <|-- Spiral

1.1 Waterfall Model: The Classic Linear Approach

Definition: A sequential, phase-based model where each phase must complete before the next begins. Phases:

1. Requirements (gather user needs)
2. Design (system architecture)
3. Implementation (coding)
4. Testing (QA)
5. Deployment (release)
6. Maintenance (bug fixes)

When to Use:

• Projects with clear, unchanging requirements (e.g., government systems like Nepal’s voter ID portal).
• Regulated industries (e.g., NTC’s billing software).

Pros:

• Simple to manage.
• Works well for documentation-heavy projects.

Cons:

• No going back: Changes in later phases are costly.
• Late testing: Bugs found in deployment are expensive to fix.

Phases of the Waterfall model with feedback loops (Image: Peter Kemp / Paul Smith, CC BY 3.0, via Wikimedia Commons)

1.2 Agile Methodology: Iterative and Flexible

Definition: A non-linear, iterative approach where work is divided into small increments (sprints), with continuous feedback. Core Principles (Agile Manifesto):

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

When to Use:

• Dynamic requirements (e.g., Daraz’s frequent feature updates).
• Startups or MVP (Minimum Viable Product) development.

Pros:

• Adaptability: Changes are welcome.
• Early delivery: Functional software in weeks, not months.
• Customer satisfaction: Frequent demos ensure alignment.

Cons:

• Requires disciplined teams.
• Documentation can suffer if not managed.

REAL WORLD:

• eSewa uses Agile to roll out new payment features weekly.
• Pathao’s ride-hailing app updates driver UI bi-weekly via Agile sprints.

1.3 Rapid Application Development (RAD)

Definition: A fast, iterative model focusing on prototyping and user feedback. Key Techniques:

• Joint Application Development (JAD): Workshops with stakeholders.
• Reusable components: Pre-built modules (e.g., Khalti’s payment API).
• Automated tools: Low-code platforms (e.g., Bubble.io for MVP).

When to Use:

• Short timelines (e.g., Nepal’s COVID-19 tracking app).
• High user involvement (e.g., Ncell’s USSD menu redesign).

Pros:

• Speed: Delivers working prototypes in days.
• User-centric: Reduces miscommunication.

Cons:

• Scope creep: Features keep adding.
• High risk: May not scale for large systems.

1.4 Spiral Model: Risk-Driven Iteration

Definition: Combines Waterfall’s structure with Agile’s iteration, focusing on risk analysis in each cycle. Phases per Spiral:

1. Planning: Define objectives.
2. Risk analysis: Identify threats (e.g., tech constraints).
3. Engineering: Develop prototypes.
4. Evaluation: Review with stakeholders.

When to Use:

• High-risk projects (e.g., Nepal Rastra Bank’s core banking system).
• Complex systems (e.g., NTC’s fiber-optic network upgrade).

Pros:

• Risk mitigation: Addresses issues early.
• Flexibility: Can switch between models.

Cons:

• Complex: Requires expert risk analysis.
• Costly: Multiple prototypes.

2. Agile Practices: Scrum, Kanban, and XP

Agile is an umbrella term—Scrum, Kanban, and XP are its most popular frameworks.

2.1 Scrum: The Sprint-Based Framework

Definition: Work is divided into 2-4 week sprints, with fixed roles and ceremonies. Key Components:

stateDiagram-v2
    [*] --> Sprint_Planning
    Sprint_Planning --> Daily_Standup
    Daily_Standup --> Development
    Development --> Sprint_Review
    Sprint_Review --> Sprint_Retrospective
    Sprint_Retrospective --> [*]

Roles:

• Product Owner: Defines priorities (backlog).
• Scrum Master: Removes obstacles.
• Development Team: Delivers increments.

Artifacts:

• Product Backlog: Prioritized feature list.
• Sprint Backlog: Tasks for the current sprint.
• Increment: Deliverable at sprint end.

REAL WORLD:

• Khalti’s team uses Scrum to release payment gateways every 3 weeks.
• Worked Example:
  • Sprint Goal: Add "UPI payment" to eSewa.
  • Sprint Backlog:
    • Design UPI API integration (3 days).
    • Test with 50 users (2 days).
    • Fix bugs (1 day).
  • Result: Feature deployed in 2 weeks with 95% success rate.

2.2 Kanban: Visual Workflow Management

Definition: A visual board (e.g., Trello, Jira) tracking work items through stages with WIP (Work in Progress) limits. Key Concepts:

• Columns: "To Do," "In Progress," "Done."
• Cards: Tasks with details.
• WIP Limits: Prevents overloading (e.g., max 3 tasks in "In Progress").

REAL WORLD:

• Pathao’s support team uses Kanban to track driver complaints:
  • Column 1 (To Do): New tickets.
  • Column 2 (In Progress): Being resolved (WIP limit = 5).
  • Column 3 (Done): Closed with feedback.

2.3 Extreme Programming (XP): Quality-First Agile

Definition: Focuses on technical excellence and customer feedback via:

• Pair Programming: Two devs work together.
• Test-Driven Development (TDD): Write tests before code.
• Continuous Integration (CI): Merge code frequently.

REAL WORLD:

• Ncell’s app development team uses XP to ensure zero-downtime updates.
• Worked Example:
  • Feature: Add "Emergency SOS" in Pathao app.
  • XP Steps:
    1. Write test for SOS button (fails).
    2. Code the button (passes test).
    3. Pair with QA to test edge cases (e.g., no network).

3. Enhancing Software Quality: Techniques and Metrics

Quality isn’t an afterthought—it’s built in via:

1. Reviews: Peer code reviews (e.g., GitHub pull requests).
2. Testing:
   • Unit Testing: Test individual functions.
   • Integration Testing: Test modules together.
   • System Testing: Test the whole system.
3. Metrics:
   • Defect Density: Bugs per 1000 lines of code.
   • Cycle Time: Time from task start to finish.

REAL WORLD:

• eSewa uses automated testing (Selenium) to catch payment failures before release.
• Nepal Stock Exchange (NEPSE) relies on manual reviews for trading system updates to avoid market crashes.

Unit, integration, and system testing layers (Image: Mike Wacker, Public domain, via Wikimedia Commons)

4. Methodology Comparison Table

5. Choosing the Right Methodology

Decision Factors:

1. Project Size:
   • Small: Agile or RAD.
   • Large: Spiral or Waterfall.
2. Requirements Stability:
   • Fixed: Waterfall.
   • Dynamic: Agile.
3. Budget:
   • Tight: RAD (fast but risky).
   • Flexible: Spiral (risk-aware).
4. Team Expertise:
   • New to Agile? Start with Scrum.
   • Need speed? Try Kanban.

REAL WORLD:

• Daraz Nepal uses Agile (Scrum) for its e-commerce platform because customer demands change daily.
• NTC’s fiber network upgrades use Spiral to manage technical risks like signal interference.

In the Real World

1. eSewa’s Payment System

   • Methodology: Agile (Scrum) with 2-week sprints.
   • Why? Users expect new features (e.g., QR payments) every few weeks. Scrum allows eSewa to prioritize based on user feedback and government regulations.
   • Quality Technique: Automated regression testing ensures no payment failures after updates.

2. Pathao’s Driver App

   • Methodology: Kanban for real-time issue tracking.
   • Why? Drivers report problems (e.g., GPS glitches) constantly. Kanban’s WIP limits ensure no ticket is ignored, and the team responds within 24 hours.
   • Worked Example:
     • Board Column: "Driver Complaints" (WIP limit = 10).
     • Action: If >10 complaints pile up, Pathao’s tech team adds a new sprint to fix the issue.

3. Nepal Rastra Bank’s Core Banking System

   • Methodology: Spiral Model.
   • Why? The system handles billions of rupees. Each spiral cycle includes penetration testing to find security flaws (e.g., SQL injection risks) before deployment.
   • Real Picture: NRB’s secure data center where the core banking system runs (Image: Derrick Coetzee from Berkeley, CA, USA, CC0, via Wikimedia Commons)

Exam Tip

What Examiners Want to See

1. Definitions with Examples:
   • Don’t just say "Agile is iterative." Explain how eSewa uses sprints or how Pathao uses Kanban.
2. Comparisons:
   • Always contrast Waterfall vs. Agile in a table or bullet points.
   • Example: "Waterfall is like building a house with fixed blueprints, while Agile is like renovating a house room by room based on the owner’s feedback."
3. Quality Techniques:
   • Link techniques to real tools:
     • Code reviews → GitHub/GitLab.
     • Testing → Selenium (automated), JIRA (manual).
4. Diagrams:
   • Draw (or describe) a Scrum board, Kanban column, or Spiral cycle in your answer.
   • Example:

     Sprint 1: [ ] Add login | [X] Fix bug | [ ] Test API
     

5. Common Pitfalls:
   • ❌ "Agile has no documentation." → ✅ "Agile prioritizes working software but uses lightweight docs like user stories."
   • ❌ "Waterfall is obsolete." → ✅ "Waterfall is still used for regulated projects like NTC’s billing system."

High-Score Answer Structure

For a 5-mark question like "Explain Agile practices with examples":

1. Define Agile (1 mark).
2. List 2 frameworks (Scrum, Kanban) with one key feature each (1 mark).
3. Give 2 Nepali examples (eSewa + Pathao) with how they apply the framework (2 marks).
4. Compare with Waterfall (1 mark).

Practice Question with Model Answer

Question: "How does Daraz use software development methodologies? Explain with a suitable methodology and quality technique."

Model Answer: Daraz Nepal primarily uses the Agile methodology with Scrum frameworks to develop its e-commerce platform. Here’s how:

1. Methodology: Scrum

   • Daraz divides development into 2-week sprints, with daily standups to track progress.
   • Example: The "Wishlist Feature" was developed in a single sprint:
     • Sprint Planning: Team selected 3 tasks (UI design, backend integration, testing).
     • Daily Standups: Each developer reported blockers (e.g., API delays).
     • Sprint Review: Stakeholders tested the feature with 1000 users; feedback led to a fix for mobile lag.

2. Quality Technique: Automated Testing

   • Daraz uses Selenium for regression testing to ensure new features (e.g., "One-Click Checkout") don’t break existing functions.
   • Metric: Defect Density is tracked—Daraz aims for <0.5 bugs per 1000 lines of code.

3. Why Agile?

   • Dynamic Requirements: Customer demands (e.g., cash-on-delivery options) change frequently.
   • Competitive Edge: Faster releases than competitors using Waterfall.

Visual:

sequenceDiagram
    participant User
    participant Daraz_ScrumTeam
    participant QA
    User->>Daraz_ScrumTeam: Requests "Add to Wishlist"
    Daraz_ScrumTeam->>Daraz_ScrumTeam: Sprint Planning (2 weeks)
    Daraz_ScrumTeam->>QA: Automated Test Suite (Selenium)
    QA-->>Daraz_ScrumTeam: Bug Report (0 critical)
    Daraz_ScrumTeam->>User: Deploys Feature