Software Process Models: Types, Phases & Selection Criteria

What is a Software Process Model?

A software process model defines the structured set of activities, actions, tasks, milestones, and work products needed to develop software. It acts as a blueprint for how development teams organize work, manage risks, and deliver software efficiently.

Why Do We Need Process Models?

• Provide a framework for development teams.
• Ensure consistency and repeatability.
• Help manage risks (e.g., budget overruns, delays).
• Improve communication between stakeholders.
• Enable measurement and improvement (e.g., time, cost, quality).

Key Phases in Software Development (Common Across Models)

All software process models include these core phases, but their order and overlap vary:

1. Requirements Gathering

• Goal: Understand what the software should do (functional/non-functional needs).
• Techniques:
  • Interviews, surveys, use cases, prototypes.
  • Example: For eSewa, requirements might include:
    • Functional: Online payment processing, user authentication.
    • Non-functional: 99.9% uptime, support for multiple banks.

2. System Design

• Goal: Define how the software will work (architecture, modules, interfaces).
• Outputs:
  • Architectural diagrams (layered, client-server).
  • Database schemas (ER diagrams).
  • API specifications.

3. Implementation (Coding)

• Goal: Write source code based on design.
• Best Practices:
  • Follow coding standards (e.g., PEP 8 for Python).
  • Use version control (Git, SVN).
  • Example: Khalti uses microservices for payment processing.

4. Testing

• Goal: Ensure the software works as intended and is free of bugs.
• Types of Testing:
  • Unit testing (individual components).
  • Integration testing (modules together).
  • System testing (entire system).
  • User acceptance testing (UAT).

5. Deployment

• Goal: Release the software to end-users.
• Steps:
  • Install on production servers.
  • Monitor performance.
  • Example: Daraz deploys updates incrementally to avoid downtime.

6. Maintenance

• Goal: Fix bugs, add new features, and optimize performance.
• Types:
  • Corrective (fixing errors).
  • Adaptive (updating for new environments).
  • Perfective (improving performance).
  • Example: NTC’s billing system undergoes quarterly updates for new regulations.

Types of Software Process Models

Each model has unique strengths and weaknesses. Choose based on project size, risk, budget, and flexibility needs.

1. Waterfall Model (Linear Sequential Model)

Definition: A strictly sequential approach where each phase must be completed before the next begins.

flowchart LR
    A["Requirements"] --> B["Design"]
    B --> C["Implementation"]
    C --> D["Testing"]
    D --> E["Deployment"]
    E --> F["Maintenance"]

Advantages

✅ Simple and easy to understand. ✅ Well-documented (good for compliance). ✅ Works well for small, well-defined projects.

Disadvantages

❌ No going back (changes are expensive). ❌ Late testing (bugs found only at the end). ❌ Not suitable for dynamic requirements.

When to Use?

• Government projects (e.g., NTC’s network upgrades).
• Regulated industries (e.g., banking systems).
• Fixed requirements (e.g., a simple ATM software).

2. Iterative Model

Definition: Repeats development cycles (mini-waterfalls) to refine the product incrementally.

flowchart TD
  A["Plan"] --> B["Design"]
  B --> C["Implement"]
  C --> D["Test"]
  D -->|"Feedback"| A
  caption **Iterative Model: Mini-waterfall cycles with feedback**

Advantages

✅ Early feedback (reduces risk). ✅ Flexible (can adapt to changes). ✅ Better risk management.

Disadvantages

❌ Higher initial cost (multiple cycles). ❌ Requires clear scope per iteration.

When to Use?

• eSewa’s mobile app updates (continuous improvements).
• Pathao’s ride-hailing features (adding new payment methods).

3. Incremental Model

Definition: Delivers parts of the system in chunks (each increment adds new functionality).

Advantages

✅ Early delivery of usable features. ✅ Lower risk (each part is tested). ✅ Customer feedback early.

Disadvantages

❌ Requires clear module separation. ❌ Integration challenges (different increments must work together).

When to Use?

• Daraz’s marketplace (adding sellers, products, payments in phases).
• Banking software (core banking first, then mobile app).

4. Spiral Model (Risk-Driven)

Definition: Combines iterative development with risk analysis (each loop adds a new dimension).

flowchart LR
  A["Plan"] --> B["Risk Analysis"]
  B --> C["Engineering"]
  C --> D["Evaluate"]
  D -->|"Feedback"| A
  caption **Spiral Model: Risk-driven iterative loops**

Advantages

✅ High risk management. ✅ Flexible and adaptable. ✅ Good for large, complex projects.

Disadvantages

❌ Complex and expensive. ❌ Requires expert risk analysis.

When to Use?

• Defense software (high security risks).
• Nepal Rastra Bank’s core banking system.

5. Agile Model (Iterative + Incremental)

Definition: Breaks work into small, manageable chunks (sprints) with continuous delivery.

Advantages

✅ Fast delivery (working software every 2-4 weeks). ✅ Customer collaboration (feedback-driven). ✅ Adaptable to changes.

Disadvantages

❌ Requires disciplined teams. ❌ Documentation can be lacking. ❌ Not suitable for highly regulated projects.

When to Use?

• Khalti’s payment gateway (weekly updates).
• WhatsApp’s feature releases (end-to-end encryption, payments).

6. V-Model (Validation & Verification)

Definition: Extends waterfall by adding testing phases in parallel.

Advantages

✅ Strong focus on testing. ✅ Good for safety-critical systems.

Disadvantages

❌ Rigid (changes are difficult). ❌ Late testing of non-functional requirements.

When to Use?

• Medical software (patient monitoring systems).
• Air traffic control systems.

Comparison Table: Process Models

How to Choose the Right Process Model?

Use this decision flowchart to select the best model:

flowchart TD
  A["Project Size"] --> B{"Small?"}
  B -->|"Yes"| C["Waterfall or V-Model"]
  B -->|"No"| D["Project Risk"]
  D --> E{"High?"}
  E -->|"Yes"| F["Spiral or Agile"]
  E -->|"No"| G["Requirements Stability"]
  G --> H{"Fixed?"}
  H -->|"Yes"| I["Waterfall"]
  H -->|"No"| J["Agile or Iterative"]
  caption **Decision Flowchart: Choosing the Right Process Model**

Key Factors to Consider

1. Project Size:
   • Small → Waterfall/V-Model.
   • Large → Agile/Spiral.
2. Risk Level:
   • High risk → Spiral/Agile.
   • Low risk → Waterfall.
3. Requirements Stability:
   • Fixed → Waterfall.
   • Changing → Agile/Iterative.
4. Customer Involvement:
   • High → Agile.
   • Low → Waterfall/V-Model.
5. Budget & Timeline:
   • Tight budget → Waterfall (predictable costs).
   • Flexible budget → Agile (adaptive costs).

In the Real World

1. eSewa (Agile Model)

• Why Agile?
  • Frequent updates (new payment methods, UI improvements).
  • Customer feedback drives development (e.g., adding Khalti integration).
• How It Works:
  • 2-week sprints with daily stand-ups.
  • Continuous testing (automated QA for transactions).

2. NTC’s Network Upgrades (Waterfall Model)

• Why Waterfall?
  • Regulated industry (telecom requires strict compliance).
  • Fixed requirements (government-mandated upgrades).
• How It Works:
  • Phase 1: Requirements (new fiber routes).
  • Phase 2: Design (network topology).
  • Phase 3: Implementation (laying cables).
  • Phase 4: Testing (signal strength checks).
  • Phase 5: Deployment (gradual rollout).

3. Daraz’s Marketplace (Incremental Model)

• Why Incremental?
  • Scalable growth (adding sellers, products, logistics step-by-step).
  • Reduces risk (each increment is tested before full launch).
• How It Works:
  • Increment 1: Basic product listings.
  • Increment 2: User reviews & ratings.
  • Increment 3: Payment gateway integration.

4. Nepal Rastra Bank’s Core Banking (Spiral Model)

• Why Spiral?
  • High security risks (financial data protection).
  • Complex requirements (multiple banking regulations).
• How It Works:
  • Loop 1: Risk analysis (fraud detection).
  • Loop 2: Prototyping (mock transactions).
  • Loop 3: Full implementation (with security audits).

Worked Example: Choosing a Model for a Nepalese Bank’s Loan Management System

Scenario: A bank wants to develop a digital loan approval system with:

• High security requirements (sensitive customer data).
• Changing regulations (Rastra Bank updates rules frequently).
• Need for fast iterations (competitors are launching similar products).

Step-by-Step Analysis

1. Risk Level: High (financial data, compliance).
2. Requirements Stability: Changing (new laws).
3. Customer Involvement: Medium (internal bank teams + regulators).
4. Project Size: Large (integrates with core banking).

Recommended Model: Spiral (with Agile Sprints)

Why Not Waterfall?

• Too rigid for changing regulations. Why Not Pure Agile?
• Security risks require structured risk analysis (Spiral’s strength).

Exam Tip

What Examiners Look For

1. Definitions:

   • Clearly define waterfall, iterative, incremental, spiral, agile, V-model.
   • Example: "The waterfall model is a sequential, phase-based approach where each phase must be completed before the next begins."

2. Advantages & Disadvantages:

   • Compare at least two models in your answer.
   • Example:

     *"While Agile allows flexibility and fast delivery, it may lack detailed documentation, which is crucial for *regulated industries like banking."

3. Real-World Applications:

   • Link models to Nepalese companies (e.g., "eSewa uses Agile for rapid updates").
   • Explain why a model was chosen (e.g., "NTC uses Waterfall because of strict government compliance").

4. Diagrams:

   • Draw process flowcharts (e.g., waterfall vs. spiral).
   • Use tables to compare models (as shown above).

5. Scenario-Based Questions:

   • If asked: "Which model would you choose for a traffic management system for Kathmandu?"
   • Answer:

     *"I would recommend the Spiral Model because:

     • High risk (traffic accidents, public safety).
     • Changing requirements (new roads, festivals).
     • Need for structured risk analysis (e.g., sensor failures)."*

Common Mistakes to Avoid

❌ Mixing up iterative and incremental:

• Iterative = repeating cycles (same phases).
• Incremental = adding chunks (different parts).

❌ Ignoring real-world constraints:

• Always justify your choice (e.g., "Agile is not suitable for Nepal Rastra Bank because of audit requirements").

❌ Overlooking testing phases:

• In V-model, testing is parallel to development—don’t forget this key difference!

Final Checklist for Full Marks

✔ Define each model clearly. ✔ Draw diagrams (flowcharts, comparison tables). ✔ Relate to Nepalese examples (eSewa, NTC, banks). ✔ Justify model selection with risk, size, and requirements. ✔ Discuss advantages/disadvantages with real-world trade-offs.