Skip to content
Tutorials Center
My learning

Topics

Lesson 5 of 50 ยท The SDLC and Process Models

The Waterfall Model

Learn the waterfall model of software development: sequential phases, its strengths and weaknesses, the cost of late change and where it still fits.

The waterfall model is the classic plan-driven process: the project moves through the SDLC phases one after another, and each phase finishes completely before the next begins. Requirements are fixed first, then design, then implementation, then testing, then deployment and maintenance. The name comes from the way the diagram steps downward like water over a series of falls.

It is often presented as an old-fashioned mistake, but that is only half true. Waterfall is a good fit for some projects and a bad fit for many; understanding why will help you choose well in Choosing a Process Model. The model itself is a way of organizing work, so the diagrams are text and the runnable examples are plain JavaScript stand-ins that model schedules and costs with illustrative numbers. They are not measurements of real projects.

How waterfall works

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

Work flows downward; in the pure form there is no way back up.

Each phase ends with a reviewed document or product (a signed specification, an approved design, tested code) and the next phase starts from it. Teams usually specialize by phase: analysts hand over to designers, who hand over to developers, who hand over to testers. In the 1970 paper that is often credited with drawing the diagram, Winston Royce actually warned that this pure form is risky and recommended feedback between steps; the strictly one-way version became popular in practice, not by his advice.

Waterfall in one picture

Sequential One phase after another.
Document-driven Each phase ends with a signed deliverable.
Frozen scope Requirements are fixed early.
Predictable Plan the whole schedule up front.
1 / 2

Strengths

Waterfall earns its place for reasons that are real:

  • Simple to understand and manage. Everyone knows which phase is current and what comes next.
  • Clear milestones and documents. This helps contracts, audits and handovers between organizations.
  • Early planning of cost and schedule. The whole scope is known, so the budget can be agreed up front.
  • Works with stable requirements. If the problem will not change, getting it right once is efficient.
  • Fits regulated environments. Safety standards often require specified, traceable documents; see the V-model for a variant that suits them.

Weaknesses

  • Late feedback. A working product appears only near the end, when users first see it and discover what they really wanted.
  • Hard to change. Requirements are assumed stable, but they rarely are. A change after sign-off means reopening documents and reworking later phases.
  • Risk is pushed to the end. Integration problems and performance surprises show up during testing, when time is short.
  • Testing is squeezed. Phases that run late eat the testing phase, which is exactly the one that protects quality.
  • Poor for unclear problems. If the team does not know yet what to build, writing it all down first produces confident-sounding but wrong documents.

The cost of late change

A widely repeated idea in software engineering is that the later a defect or change is found, the more it costs to fix. A mistake in a requirement fixed during requirements review is a conversation; the same mistake found in production means rework in the design, the code, the tests, the documentation and sometimes data already collected from users. Early studies, popularized by Barry Boehm, suggested that the cost can grow by large factors between early phases and operation. Exact multipliers differ widely between projects and have been debated, and teams with strong test automation and frequent releases can flatten the curve. Treat any single table of multipliers as illustrative.

The model below uses invented but plausible multipliers to make the shape visible: a fix costs one unit in the requirements phase and more with each later phase.

JS Cost of fixing one requirement mistake, by phase

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

No output.

The stand-in does not prove that real fixes cost 20 times more; it shows why teams invest in early reviews, prototypes and frequent feedback. If you were designing a process, the lesson is to move discovery earlier, which is exactly what iterative models do.

Why change gets expensive: a schedule view

The other half of the problem is schedule. In waterfall each phase has its own duration, and a change request that reopens an earlier phase must pass through every later phase again. This second stand-in computes the delay for a change request arriving at different times.

JS Delay caused by a change request

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

No output.

A change during requirements costs about a week; the same change during testing costs more than eight weeks in this model. The percentages are assumptions, but the pattern holds: each completed phase becomes more work to reopen.

When waterfall still fits

Waterfall is a sensible choice when:

  • requirements are well understood and stable (for example porting a system whose behavior is already defined, or implementing a published standard);
  • the cost of a late mistake is very high (safety-critical or regulated software);
  • the contract requires fixed scope, price and documents;
  • the technology is familiar, so there are few unknowns to learn;
  • the team is distributed or outsourced and relies on written specifications.

Even then, many teams soften it with prototypes, reviews at each gate, and parallel work between phases. A purely one-way waterfall is rare today; plan-driven processes with feedback loops are common. For problems where users cannot tell you everything in advance, prefer an approach with earlier working software, as described in the next lesson.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. What is the defining feature of the waterfall model?

    In waterfall the phases are sequential. Iterative and agile models repeat cycles instead.
  2. 2. Why is a requirement mistake found in production expensive to fix?

    The later it is found, the more finished work depends on the mistake and must be redone.
  3. 3. For which project is waterfall most appropriate?

    Stable, well understood requirements and a fixed contract favor a plan-driven process.
  4. 4. What should you conclude from the 'cost by phase' multipliers in the lesson?

    The numbers are invented to show a trend. Real multipliers vary and have been debated, but the direction is widely accepted.

Summary

  • Waterfall runs requirements, design, implementation, testing, deployment and maintenance in strict sequence, each ending with a signed deliverable.
  • Strengths: simplicity, clear milestones, early cost planning and suitability for stable, regulated work.
  • Weaknesses: late user feedback, expensive change, risk discovered late and a squeezed test phase.
  • The later a mistake is found, the more it costs, although exact multipliers vary between projects.
  • It still fits stable, high-stakes, contract-driven projects, usually with some feedback loops added.

Next: V-Model, Iterative and Incremental Models.