Skip to content
Tutorials Center
My learning

Topics

Lesson 6 of 50 ยท The SDLC and Process Models

V-Model, Iterative and Incremental Models

Learn how the V-model pairs development with testing, how iterative and incremental models differ, and how prototyping reduces risk and delays.

The waterfall model has two famous problems: testing comes last, and users see the product only at the end. Two families of models were created to fix them. The V-model keeps the sequence but plans testing from the first phase. Iterative and incremental models break the work into repeated cycles so that working software and feedback arrive early. This lesson explains both and compares them.

These models describe how to organize work, so the diagrams are text. The runnable examples are plain JavaScript stand-ins with invented durations; they compare shapes of schedules, not real projects.

The V-model: verification and validation

The V-model (the name comes from the shape of its diagram) pairs every development phase on the left with a test level on the right. Two words matter:

  • Verification asks "are we building the product right?", meaning does it conform to its specification. It is checked with reviews, inspections and tests against the design.
  • Validation asks "are we building the right product?", meaning does it meet the real needs of its users. It is checked by acceptance testing with the customer.
flowchart TD
    A["Requirements"] --> B["System design"]
    B --> C["Architecture design"]
    C --> D["Module design"]
    D --> E["Coding"]
    E --> F["Unit testing"]
    F --> G["Integration testing"]
    G --> H["System testing"]
    H --> I["Acceptance testing"]
    A -. "acceptance tests planned from" .-> I
    B -. "system tests planned from" .-> H
    C -. "integration tests planned from" .-> G
    D -. "unit tests planned from" .-> F

Each design level has a matching test level; the dotted lines show that the tests are planned as the design is written.

The key benefit is that test planning starts early. When requirements are written, acceptance tests are drafted from them; when the architecture is designed, integration tests are drafted. This exposes ambiguous requirements ("how would I test this?") while they are cheap to fix. See testing levels for what each level checks.

V-model pairs

Requirements Acceptance testing
Architecture Integration testing
Module design Unit testing

Left side builds the product. Right side checks it.

1 / 2

The V-model shares waterfall's weakness: it is still sequential, so requirements are assumed stable and users see software late. It is popular in safety-critical fields such as automotive, avionics and medical devices, because standards there demand evidence that every requirement is traced to a design element and to a test.

Iterative development

In iterative development you build the whole product roughly, then improve it in repeated passes. Each iteration goes through requirements, design, build and test, and refines what already exists: the first version might have a rough interface and a few features working poorly; later versions improve quality and completeness. You get feedback early on the product as a whole.

Incremental development

In incremental development you build the product piece by piece. Each increment is a finished, usable slice of functionality that is added to the previous ones. The first release might contain only login and search; the next adds reports; the next adds exports. Users start getting value earlier, and the most important features are delivered first.

The two ideas are different but usually combined: most modern processes are iterative and incremental (work in short cycles, each producing a usable slice, and refine the slices as feedback arrives). A useful picture is painting. An iterative artist sketches the whole canvas and refines it in layers. An incremental artist finishes one corner completely, then the next. Agile teams do both.

Aspect Waterfall Iterative Incremental
Unit of work Whole product, once Whole product, refined Slice of features
First working software End Early, but rough After first increment
Change handling Expensive Absorbed each cycle Absorbed per increment
Main risk Wrong product at the end Never-ending refinement Slices that do not fit together

The last row matters: incremental delivery needs an architecture that allows slices to fit together, often planned briefly up front (architecture styles).

Comparing delivery timelines

This stand-in models a product with four features, each taking four weeks to analyze, build and test. Waterfall delivers everything at the end. Incremental delivery releases a feature every four weeks. Each feature carries a business value per week once it is in use, so you can compare the value gained by week 24. (Values are invented, and the model ignores integration cost, which in practice is higher for incremental delivery.)

JS Waterfall versus incremental delivery

Press Run (or Ctrl + Enter) to see the console output here.

No output.

The total effort is the same, but the incremental plan delivers more value by week 24 because users start benefiting from the best features sooner, and the team receives real feedback after week 4 instead of week 16. Delivering the highest-value items first is a core idea behind agile backlogs (Scrum).

Prototyping

A prototype is a quick, partial version built to answer a question, not to be shipped. Two common kinds:

  • Throwaway (rapid) prototypes explore unclear requirements. Users click through a mock-up, say "no, not like that", and the prototype is discarded. They are cheap because they skip quality, tests and error handling.
  • Evolutionary prototypes start rough and are gradually hardened into the real product. They are faster to start but risky: shortcuts taken for speed can become permanent technical debt.

Prototyping reduces requirements risk (building the wrong thing) and technical risk (trying whether an approach works at all). Decide at the start whether the prototype will be thrown away, and say so loudly: managers who see a working prototype are tempted to ship it.

The second stand-in shows prototyping as a cost decision. Suppose there is a chance that the requirements are wrong, and a wrong requirement costs a lot to fix late. A cheap prototype that finds the problem early pays off when the chance is high enough.

JS When does a prototype pay off?

Press Run (or Ctrl + Enter) to see the console output here.

No output.

The break-even point is where the prototype's own cost equals the expected savings. With these numbers it is about a 20% chance of being wrong (the two costs are almost equal there), so the prototype is a bad deal when the requirements are probably right and a good one when they are shaky, which is the same trade-off that the spiral model formalizes as risk analysis.

Check your understanding

Quick check ยท 5 questions

of 5 answered You scored / 5 ยท perfect!

  1. 1. What is the difference between verification and validation?

    Verification compares the product with its specification. Validation compares it with what users actually need.
  2. 2. What is the main advantage of the V-model over pure waterfall?

    Planning acceptance, system and integration tests early exposes unclear requirements and designs while they are cheap to fix.
  3. 3. Which description is incremental development?

    Incremental development delivers complete slices. Iterative development refines the whole in repeated passes. Most teams combine both.
  4. 4. Why should a throwaway prototype be clearly labelled as such?

    A working prototype looks finished, but it skipped quality work. Shipping it turns its shortcuts into debt.
  5. 5. In the delivery comparison, why did the incremental plan deliver more value by week 24?

    Total effort was the same, but earlier releases meant more weeks of use, and sorting by value put the best features first.

Summary

  • The V-model pairs each development phase with a test level and plans tests early; it verifies against specifications and validates against user needs.
  • Iterative development refines the whole product in repeated cycles; incremental development delivers complete slices one by one; most modern processes combine them.
  • Incremental delivery gives earlier value and feedback, but it needs an architecture in which the slices fit together.
  • Prototypes reduce requirements and technical risk; decide up front whether they will be thrown away.

Next: Spiral Model and Risk-Driven Development.