Computer Engineering is coming soon

We're still writing and reviewing the notes for every subject, and we'll open it when every subject is ready. Meanwhile you can practise aptitude, ask Aria about any subject, or see the branches that are ready.

Prescriptive process models: waterfall, V-model and incremental

Prescriptive process models (Waterfall, V‑model, Incremental) describe fixed, planned sequences of software development phases and how engineers choose and apply them.

Drafted with Aria, reviewed by the AiCanCode.org team · Updated . How we write and check our notes. Spotted an error? Use Give Feedback at the bottom of the page.

Why it matters

When an engineering team must plan, estimate and control a software project, they choose a process model. A prescriptive process model is a style of plan that prescribes ordered phases and responsibilities. Engineers use these models to allocate time, choose appropriate testing activities, and decide when changes are affordable.

Key ideas

  • Artifact — a deliverable produced during a phase (for example, a requirements specification, a design document, or source code). Artifacts are used as input to later phases.

  • Waterfall model (definition): A linear, sequential prescriptive model where each phase must finish before the next begins. Exact statement universities expect: "In the Waterfall model the development lifecycle is a sequence: Requirements → System Design → Detailed Design → Implementation → Integration and Testing → Deployment → Maintenance; no phase is revisited in normal flow." Assumption: low change frequency after requirements.

    • To draw the Waterfall diagram: draw seven boxes left-to-right, arranged horizontally. Label them, in order: "Requirements", "System Design", "Detailed Design", "Implementation (Coding)", "Integration & Testing", "Deployment", "Maintenance". Draw single arrows from each box to the next. Optionally add a faint backward arrow from Maintenance back to Requirements labelled "feedback/maintenance" to show corrective maintenance.
  • V‑model (definition): A development model that pairs each development phase on the left branch with a corresponding testing activity on the right branch; the shape visually forms a V. Exact statement: "The V‑model expands the waterfall by explicitly linking each development phase to a corresponding level of testing: Requirements ⇄ Acceptance Testing, System Design ⇄ System Testing, Architectural/High‑Level Design ⇄ Integration Testing, Detailed/Module Design ⇄ Unit Testing; Implementation (Coding) sits at the bottom of the V." Assumption: test planning occurs early and maps directly to design artifacts.

    • To draw the V‑model: draw a large V. On left descending leg, from top to bottom, place boxes: "Requirements", "System Design", "Detailed/Module Design", "Implementation (Coding)". At the bottom point, place "Implementation (Coding)". On the ascending right leg, place boxes from bottom to top: "Unit Testing", "Integration Testing", "System Testing", "Acceptance Testing". Draw connecting lines across the V from each left-phase box to its matching right-phase test box and label lines with the artifact used (e.g., Requirements → Acceptance Test Plan).
  • Incremental model (definition): A model where the system is built and delivered in increments (also called builds or iterations); each increment adds functional slices of the final system. Exact statement: "The Incremental model partitions the requirements into increments; each increment follows a mini‑waterfall (requirements → design → implementation → test) and produces a usable partial product; increments are integrated to form the final system." Assumption: requirements can be partitioned and early delivery of partial functionality is valuable.

  • Key trade-offs (exact exam-style summary):

    1. Waterfall gives strong predictability and documentation but is inflexible to requirement change.
    2. V‑model enforces early test planning and traceability but still assumes stable requirements.
    3. Incremental improves risk reduction and early delivery but requires careful architectural planning to avoid integration problems.
  • When to choose which (short rules):

    • Choose Waterfall when requirements are well known, regulatory compliance needs strong documentation, and change is expensive administratively.
    • Choose V‑model when verification and validation must be explicit (safety‑critical, regulated domains), and when mapping between requirements and test is needed.
    • Choose Incremental when parts of the system can be delivered early, or when stakeholders need frequent demonstrations and the architecture supports incremental integration.

Formulas

(This topic is conceptual. Use these canonical sequences as syntax to remember.)

Requirements -> System Design -> Detailed Design -> Implementation -> Integration & Testing -> Deployment -> Maintenance

Requirements <-> Acceptance Testing

System Design <-> System Testing

Architecture/High-Level Design <-> Integration Testing

Detailed/Module Design <-> Unit Testing

Increment N: (ReqN -> DesignN -> ImplementN -> TestN) -> IntegrateWithPrevious

Symbols: these lines show order or mapping. Use them when writing exam answers or drawing process diagrams.

Worked examples

Example 1 — Waterfall: writing a control-panel firmware for a factory machine (theory question model answer)

Question: Describe how you would apply the Waterfall model to build firmware for a temperature‑controlled industrial oven. Mention key documents and a short justification.

Model answer (step-by-step):

  1. Requirements phase: produce a signed Software Requirements Specification (SRS) listing functional requirements (setpoint control, safety interlocks), nonfunctional requirements (real‑time constraints, safety integrity level), and interfaces.
  2. System Design: create architecture diagrams showing hardware modules, RTOS choices and I/O.
  3. Detailed Design: write module-level designs, data structures and state machines for alarm handling.
  4. Implementation: code in C and produce source files and build scripts.
  5. Integration & Testing: perform unit tests, integrate modules, run system tests with actual hardware using test cases derived from SRS.
  6. Deployment: flash firmware to devices and run acceptance tests with factory engineers.
  7. Maintenance: log and fix defects; use strict change control.

Justification: firmware safety and regulatory traceability require documented requirements and mapped tests. Waterfall keeps evidence of decisions and traceability.

Example 2 — V‑model traceability: mapping tests to requirements (short answer with diagram steps)

Task: For a banking application requirement "Users must be able to transfer funds between accounts", list the corresponding development artifact and test levels.

Answer: Requirement artifact — SRS section "Funds Transfer". System Design artifact — sequence diagrams showing transaction flow. Module Design — classes or services: AuthenticationService, TransferService. Implementation — code for TransferService and DB stored procedures.

Testing mapping: Acceptance Test: end‑to‑end transfer scenario; System Test: transaction processing with multiple clients; Integration Test: TransferService with AuthenticationService and Database; Unit Test: TransferService methods and error handling. In an exam draw the V and connect the "Funds Transfer" requirement at the top left to "Acceptance Test" at the top right.

Example 3 — Incremental planning with small schedule (numerical-like trace)

Scenario: 12‑week project to build an e‑commerce checkout with three increments: core checkout (weeks 1–6), payment integration (weeks 4–9), shipping & tracking (weeks 8–12). Show how overlaps work.

Plan (weekly outline):

  • Increment 1 (weeks 1–6): requirements1 (wk1), design1 (wk2), implement1 (wk3–4), test1 (wk5–6) → deliver usable cart and checkout page.
  • Increment 2 (weeks 4–9): requirements2 (wk4), design2 (wk5), implement2 (wk6–7), test2 (wk8–9) → add payment gateway.
  • Increment 3 (weeks 8–12): requirements3 (wk8), design3 (wk9), implement3 (wk10–11), test3 (wk11–12) → add shipping/tracking.

Trace: increments overlap to reduce calendar time; final integration tests occur after each increment; a regression test suite must run before each incremental release.

Common mistakes

  • Drawing the V‑model with tests on the same side as development phases (must be on opposite legs of the V and mapped across).
  • Treating Incremental as the same as Agile/Scrum. Incremental is prescriptive and can be plan-driven; Agile is adaptive. Use the other topic names for comparisons.
  • Omitting artifacts in each phase (e.g., not mentioning SRS for requirements, test plans in V‑model).

For your exam

Question types you will see: definitions (define each model), short notes (advantages/disadvantages), diagram drawing (draw and label Waterfall/V‑model/incremental), mapping/traceability questions (map test levels to development phases), and planning questions (create an incremental schedule and argue choice). Full-marks answers include: clear definitions, labelled diagrams with arrows and artifact names, assumptions stated (e.g., stability of requirements), pros and cons, and at least one concrete example or plan.

What full answers must include (checklist):

  • Define the model and related terms (phase, artifact, verification, validation).
  • Draw a neat diagram and label phases and mappings exactly as required.
  • State assumptions and main trade-offs.
  • For incremental questions: show at least one increment plan and how integration/regression testing will be handled.

Quick check

  1. What is the main assumption behind choosing a Waterfall model?
  2. In the V‑model, which testing level corresponds to Detailed/Module Design?
  3. Give one advantage and one disadvantage of the Incremental model.

Answers: 1) Requirements are stable/changes are rare and expensive; 2) Unit Testing; 3) Advantage: early delivery and reduced risk; Disadvantage: possible integration complexity or architecture erosion if not planned.

Finished this topic? Mark it so your progress, study plan and readiness keep up.

Stuck on something here?