# SDLC Models — Waterfall, Iterative, Prototype, Spiral, V-Model and RAD

Source: https://skills101.in/learn/software-engineering/sdlc-process-models — Skills101 free tutorial (Software Engineering). Updated 2026-11-09.

Every project goes through requirements, design, coding and testing. A **process model** decides the *order* — once, in a straight line, or many times in small loops.

## 1. Waterfall (classic / linear sequential)

![Waterfall model: requirements, system design, implementation, testing, deployment and maintenance flow downwards one after another](https://skills101.in/learn-img/software-engineering/waterfall.svg)

Each phase is finished and signed off before the next starts.

- **Pros:** simple, easy to manage, clear documents and milestones.
- **Cons:** working software appears only at the end; changing requirements later is very costly; customer feedback comes late.
- **Use when:** requirements are clear and stable, e.g. a government payroll module with fixed rules.

## 2. Incremental model

Build the product in **increments**: the first release has core features, each later release adds more. Each increment is a mini-waterfall.

- **Pros:** early working software; easier to test small parts; risk spread out.
- **Cons:** needs good overall design up front so increments fit together.
- **Example:** a banking app ships balance + statements first, then UPI, then loans.

## 3. Iterative model

Build a rough version of the **whole** system, then improve it in iterations (v1 → v2 → v3) using feedback. Incremental *adds pieces*; iterative *refines the whole*. Modern Agile mixes both.

## 4. Prototyping model

Quickly build a **throwaway prototype** (screens, mock flow) so the customer can see and react, then write the real requirements.

- **Use when:** the customer is unsure what they want (e.g. a new UI-heavy app).
- **Risk:** the customer thinks the prototype is the finished product; developers keep its quick-and-dirty code.

## 5. Spiral model (Barry Boehm)

The project goes round a spiral many times. Each loop has four quadrants:

1. **Determine objectives**, alternatives and constraints.
2. **Identify and resolve risks** (often by building a prototype).
3. **Develop and test** the next level of the product.
4. **Plan the next iteration** with customer review.

- Its key feature: **risk analysis** in every loop.
- **Use when:** the project is large, expensive and risky (defence, space, new technology).
- **Cons:** costly, needs risk-analysis expertise; overkill for small projects.

## 6. V-model (verification and validation model)

![V-model: requirements, system design, architecture and module design on the left; coding at the bottom; unit, integration, system and acceptance testing on the right, each test linked to a design step](https://skills101.in/learn-img/software-engineering/v-model.svg)

An extension of waterfall where **each development phase has a matching test phase**, and the test is *planned* during that development phase.

- Requirements ↔ acceptance testing; system design ↔ system testing; architecture ↔ integration testing; module design ↔ unit testing.
- **Pros:** testing is planned early; good for safety-critical systems (medical, automotive).
- **Cons:** still rigid like waterfall.

## 7. RAD (Rapid Application Development)

Very short cycles (60–90 days) using reusable components, code generators and small teams working in parallel. Good when the system can be split into modules and users are available for quick feedback.

## Comparison

| Model | Requirements | Risk handling | Customer sees software | Best for |
|---|---|---|---|---|
| Waterfall | fixed, clear | poor | at the end | small, stable projects |
| Incremental | mostly known | medium | after first increment | phased releases |
| Prototype | unclear | medium | early (prototype) | UI-heavy, unclear needs |
| Spiral | evolving | **excellent** | each loop | large, risky projects |
| V-model | fixed | testing focus | at the end | safety-critical |
| Agile | changing | good | every 1–4 weeks | most modern products |

Agile gets its own lesson next.

## Common mistakes

- Mixing up incremental (add pieces) and iterative (refine the whole).
- Forgetting that the spiral model's defining feature is **risk analysis**.
- Saying the V-model tests only at the end — it *plans* tests from the start.

## Quick recap

- Waterfall: linear, simple, rigid.
- Incremental/iterative: deliver early, improve with feedback.
- Prototype: clarify unclear requirements.
- Spiral: risk-driven loops (Boehm).
- V-model: each design phase has a matching test phase.


Practice quiz and free certificate: https://skills101.in/learn/software-engineering/sdlc-process-models