Water in a waterfall flows only one way: down. It never climbs back up to the top. The Waterfall Model treats software development the same way: finish the requirements completely, then move down to design, then to coding, then to testing, and never go back.
This is the oldest and simplest SDLC model, and it is the starting point for understanding every other model, because the others were mostly invented to fix its weaknesses. In this chapter we cover the classical waterfall model, its phases and documents, the idea of phase containment, the more practical iterative waterfall model, the surprising history behind the name, and exactly when Waterfall is (and is not) a good choice. We assume you know the phases from Software Development Life Cycle (SDLC).
What Is the Waterfall Model?
Waterfall model: a linear, sequential SDLC model in which the project passes through the life cycle phases one at a time, in a fixed order. Each phase must be fully completed, and its output reviewed and approved, before the next phase begins. Each phase's output is the input to the next.
It is also called the linear sequential model or the classic life cycle.
+-------------------+
| Feasibility study |
+---------+---------+
|
v
+---+---------------------+
| Requirements analysis |
| and specification (SRS) |
+---+---------------------+
|
v
+---+-----------+
| Design |
+---+-------+
|
v
+---+--------------------+
| Coding and |
| unit testing |
+---+----------------+
|
v
+---+----------------------+
| Integration and |
| system testing |
+---+------------------+
|
v
+---+-----------+
| Maintenance |
+-------------+
The steps cascade down like water flowing over the steps of a waterfall, which gave the model its name.
Key Characteristics
Sequential: one phase at a time; no overlap.
Document-driven: each phase ends with a formal document (feasibility report, SRS, design document, test plan, test report).
Milestones and sign-offs: a phase ends only when its output is reviewed and approved. This is called a baseline; later changes go through formal change control.
Single delivery: the customer receives the working software once, at the end.
No going back (in the classical version): the model assumes each phase is done correctly the first time.
Phases of the Classical Waterfall Model
The phases are the SDLC phases you already know. What makes Waterfall special is the strict hand-off between them.
Phase | Main activities | Output (deliverable) |
|---|---|---|
Feasibility study | Technical, economic and operational analysis; choose a solution strategy | Feasibility report |
Requirements analysis & specification | Gather, analyse and document all requirements; get customer sign-off | SRS document |
Design | Architecture (HLD) and detailed design (LLD) | Software design document |
Coding & unit testing | Implement each module; test each module alone | Source code, unit test results |
Integration & system testing | Integrate modules in planned steps; test the full system against the SRS (alpha, beta, acceptance) | Tested system, test reports |
Maintenance | Corrective, adaptive, perfective and preventive changes | Updated releases |
Some textbooks show deployment as a separate box between testing and maintenance; others include it in testing or maintenance. Pressman's version names the steps using his framework activities: communication → planning → modeling → construction → deployment.
Relative Effort per Phase
Students often assume coding takes most of the effort. In practice, in a typical waterfall project, testing (integration and system testing) takes the largest share of development effort, and over the whole life of a long-lived product, maintenance takes more than all development phases together. Coding is usually a smaller share than either.
Phase Containment of Errors
Since the classical model has no way to go back, an error that escapes one phase is expensive to fix later: it has already been built upon. So Waterfall puts heavy emphasis on catching errors in the same phase that created them.
Phase containment of errors: the principle of detecting and correcting an error in the same phase in which it was introduced, so that it does not propagate to later phases.
The tools for this are reviews at the end of each phase: SRS review with the customer, design walkthroughs and inspections, code reviews. They are a form of verification, as defined in the SDLC chapter.
Worked Example: Why Phase Containment Pays
Suppose a project team introduces 20 requirement defects. For illustration, assume these relative costs (in "effort units") to fix one requirement defect, depending on where it is found:
Phase where found : Requirements Design Coding Testing After release
Relative fix cost : 1 5 10 20 100
(These multipliers are only assumed for the example; real ratios vary by project, but they always increase from left to right.)
Team A holds a careful SRS review. It finds 15 defects during requirements; the other 5 slip through and are found in system testing.
Team A cost = 15 × 1 + 5 × 20
= 15 + 100
= 115 units
Team B skips the review. No defect is found during requirements; 12 are found in system testing and 8 reach customers.
Team B cost = 12 × 20 + 8 × 100
= 240 + 800
= 1040 units
Same 20 defects, but Team B spends about 9 times as much effort fixing them (1040 / 115 ≈ 9.0), and its customers saw 8 defects in production. A few hours of review in the requirements phase saved weeks of rework. This is the reasoning behind phase-end reviews.
The Iterative Waterfall Model
In reality, people make mistakes in every phase, and some are discovered only later. A tester may find that a requirement was misunderstood; a developer may find that a design cannot be implemented efficiently. The classical model has no answer except "it should not happen".
The iterative waterfall model (the name used by Rajib Mall and many Indian university syllabi) adds feedback paths from each phase to the earlier phases, so that errors discovered later can be corrected where they originated:
+---------------------------+
| Feasibility study | (no feedback path goes
+-------------+-------------+ back to feasibility)
|
v
+---------------------------+
| Requirements analysis |<---+------+------+
| and specification | | | |
+-------------+-------------+ | | |
| | | |
v | | |
+---------------------------+ | | |
| Design |----+ | |
| |<----------+------+
+-------------+-------------+ | |
| | |
v | |
+---------------------------+ | |
| Coding and unit testing |-----------+ |
| |<-----------------+
+-------------+-------------+ |
| |
v |
+---------------------------+ |
| Integration and system |------------------+
| testing |
+-------------+-------------+
|
v
+---------------------------+
| Maintenance |
+---------------------------+
Each development phase can send an error back to ANY earlier
phase (except feasibility) through the lines on the right.
Defects reported during maintenance are traced back the same way.
Important points (frequently asked):
Feedback paths let an error be fixed in the phase where it was introduced, and the work products of all later phases are then updated.
There is no feedback path to the feasibility study. Once a project is accepted, it is not normally abandoned because of a later error; the feasibility decision is treated as final.
The phases still happen in order and the product is still delivered once at the end. "Iterative waterfall" only means mistakes can be corrected by going back; it is not the same as the iterative development models in the next chapter, which deliberately plan repeated cycles.
Phase containment is still the goal: the feedback paths are for errors that escaped, not a licence to skip reviews.
Classical vs Iterative Waterfall
Aspect | Classical waterfall | Iterative waterfall |
|---|---|---|
Going back to earlier phases | Not allowed | Allowed through feedback paths |
Assumption | Every phase is done perfectly | Errors can occur and must be corrected at their source |
Practical use | Mostly a theoretical / teaching model | Used in real projects with stable requirements |
Deliveries to customer | One | One |
Feedback to feasibility | No | No |
History: Royce Did Not Recommend Pure Waterfall
The model is usually traced to Winston W. Royce's 1970 paper, Managing the Development of Large Software Systems. Here is the twist: Royce drew the simple sequential diagram and then said, in effect, that he believed in the concept but that this straightforward implementation was risky and invited failure, because problems discovered during testing could force a major redesign.
He then proposed five improvements:
Program design comes first: do a preliminary design before detailed analysis, so that constraints like storage and timing are known early.
Document the design thoroughly.
Do it twice: build an early pilot version (a kind of prototype) to learn from, then build the real one.
Plan, control and monitor testing carefully.
Involve the customer formally and continuously.
Royce never used the word "waterfall". The name appeared later in the 1970s (an early use is attributed to Bell and Thayer, 1976). Waterfall became widespread partly because standards such as the US Department of Defense's DOD-STD-2167 (1985) required document-driven, phase-by-phase development. Ironically, the model that was presented as a warning became the industry default for years.
Advantages
Simple and easy to understand, even for people with no software background.
Clear milestones and deliverables, so progress is easy to measure: "SRS approved", "design approved".
Easy to manage and contract: fixed scope, fixed phases, payments tied to deliverables.
Strong documentation, which helps new team members, maintenance, audits and regulators.
Discipline: requirements and design are thought through before coding begins.
Works well when requirements are clear and stable and the technology is well understood.
Disadvantages
Assumes requirements can be fully known at the start. In most real projects customers cannot state everything upfront, and needs change while the project runs.
Working software appears very late. The customer sees the product only at the end. If it is not what they wanted, the discovery comes after most of the budget is spent.
High risk: major problems (performance, integration, misunderstood requirements) surface only in the testing phase, when they are most expensive to fix.
Changes are costly once a phase is baselined.
Blocking states: some team members wait idle for the previous phase to finish (testers wait for code, coders wait for design).
Not suitable for large, long, complex or innovative projects, where learning during the project is essential.
Testing squeezed at the end: when earlier phases slip, the fixed deadline often eats into testing time.
When Should You Use Waterfall?
Use Waterfall when... | Avoid Waterfall when... |
|---|---|
Requirements are well understood, stable and documented | Requirements are unclear or expected to change |
The project is small or short | The project is large, long-running or innovative |
Technology is familiar to the team | New, unproven technology is involved |
Heavy documentation or regulatory approval is needed | The customer needs to see working software early |
The product is a re-implementation of a known system (e.g. porting, migration) | Market feedback must shape the product (startups, consumer apps) |
Quick Scenarios
Converting a payroll system from an old platform to a new one with identical rules: requirements are known exactly. Waterfall fits well.
A new social media app for college students: nobody knows exactly which features users will love. Waterfall is a poor choice; an incremental or agile approach is better.
Software for a fixed-scope government tender with formal documents at each stage: Waterfall (or the V-Model, if verification is critical) is common.
Waterfall Compared with Other Models
Aspect | Waterfall | Iterative / Incremental | Agile (e.g. Scrum) |
|---|---|---|---|
Requirements | Fixed upfront | Core upfront, refined per cycle | Evolve continuously |
Delivery | Once, at the end | Several working increments | Usable increment every short iteration |
Customer involvement | Mainly start and end | After each increment | Continuous |
Handling change | Expensive | Easier in later increments | Expected and welcomed |
Risk discovery | Late | Earlier | Early and continuous |
Documentation | Heavy | Moderate | Light, "just enough" |
The next chapter, Iterative & Incremental Models, shows how building in pieces fixes the "everything at the end" problem. The V-Model chapter shows a variant of Waterfall that pairs every phase with a test level.
Common Mistakes Students Make
Drawing feedback arrows into the feasibility study in the iterative waterfall model. There are none.
Calling iterative waterfall an "iterative model". It still delivers once; feedback paths only allow error correction.
Saying Royce invented and recommended waterfall. He described the sequential approach and warned that it was risky, recommending iteration and customer involvement.
Saying Waterfall is "always bad". It is a sound choice for small, well-understood, stable projects and is still used in regulated domains.
Thinking coding is the biggest phase. Testing (in development) and maintenance (over the product's life) usually take more effort.
Interview / GATE-Style Questions
1. What is the main assumption of the classical waterfall model?
That each phase can be completed correctly and fully before the next one starts, so there is never a need to go back. In particular, that all requirements can be known and frozen at the beginning.
2. What is phase containment of errors?
Detecting and correcting an error in the same phase in which it was introduced, typically through reviews at the end of each phase, so the error does not propagate into later phases where it costs much more to fix.
3. Why is there no feedback path to the feasibility study in the iterative waterfall model?
Because the feasibility decision is treated as final once the project has been accepted; errors found later are fixed in requirements, design or code, not by re-evaluating whether to do the project.
4. Which SDLC model is most suitable when requirements are well understood and stable, and the project is small? Why?
The Waterfall model. With stable requirements, the main weakness of Waterfall (inability to handle change) does not hurt, and its strengths (simplicity, clear milestones, documentation, easy management) are fully used.
5. A team finds 10 defects in requirements review (cost 1 each), 6 in system testing (cost 20 each) and 4 after release (cost 100 each). What is the total fixing cost? What would it be if all 20 had been found in the review?
10 × 1 + 6 × 20 + 4 × 100 = 10 + 120 + 400 = 530 units. If all 20 were found in review: 20 × 1 = 20 units, about 26 times cheaper.
6. List three disadvantages of the waterfall model.
Working software is available only at the end; it cannot handle changing requirements well; risks and integration problems are discovered late. Others: blocking states, unsuitability for large/complex projects, and testing getting squeezed at the end.
7. In the waterfall model, which phase usually consumes the most development effort?
Integration and system testing typically takes the largest share among the development phases. Over the whole life cycle, maintenance usually exceeds all development phases combined.
Summary
The Waterfall model performs the SDLC phases once, in strict sequence, with a reviewed deliverable at the end of each.
Phase containment (catching errors where they are introduced, via reviews) is central to it.
The iterative waterfall model adds feedback paths to earlier phases (but none to feasibility) to fix errors at their source; it still delivers once.
Royce's 1970 paper actually warned that the pure sequential approach was risky and recommended iteration and customer involvement.
Strengths: simple, manageable, well-documented. Weaknesses: late delivery, poor handling of change, late risk discovery.
Use it for small, stable, well-understood projects; avoid it when requirements are unclear or likely to change.
Next, in Iterative & Incremental Models, we see how building and delivering software in smaller pieces reduces Waterfall's risk.