Skip to content
Tutorials Center
My learning

Topics

Lesson 10 of 41 ยท Initiation and Planning

SDLC and the Waterfall Model

Learn the software development life cycle (SDLC) and the waterfall model: phases, deliverables like the SRS, testing levels, strengths, weaknesses and when waterfall still fits.

Software projects have their own life cycle: the software development life cycle (SDLC). It describes the stages software passes through from the first idea to retirement. Many process models organize these stages differently, and the oldest and best-known is the waterfall model, where each stage finishes before the next begins. Even if you work in an agile team, understanding waterfall explains what agile reacts against and where a predictive approach still wins.

The SDLC stages

  1. Planning and feasibility: is it worth building? What are the risks and costs?
  2. Requirements analysis: what must the software do?
  3. Design: how will it be structured (architecture, data, interfaces)?
  4. Implementation: writing the code.
  5. Testing: checking that it works and meets requirements.
  6. Deployment: releasing to users.
  7. Maintenance: fixing defects, adapting to change, adding features until retirement.

The waterfall model

Waterfall runs these stages in sequence. Output of one stage feeds the next, like water down steps; going back is possible but expensive.

flowchart TB
    R[Requirements] --> D[Design]
    D --> I[Implementation]
    I --> T[Testing]
    T --> M[Deployment and maintenance]

Classic waterfall: finish a phase, review it, then move on.

Each phase ends with reviewed deliverables.

Phase Typical deliverable
Requirements Software requirements specification (SRS)
Design High-level design (architecture) and detailed design documents
Implementation Source code, build scripts
Testing Test plans, test cases, test reports
Deployment Release package, user guides
Maintenance Change log, patches

The SRS

The software requirements specification records what the system will do: purpose and scope, user classes, functional requirements (features), non-functional requirements (performance, security, usability), interfaces, constraints and acceptance criteria. A good requirement is clear, testable, unambiguous and traceable to a source. "The system shall respond to a search within 2 seconds for 95% of queries" is testable; "the system shall be fast" is not.

Design documentation

Design documents typically describe the architecture (components and how they talk), data models, interface definitions, key algorithms and security approach. They let developers work in parallel and let testers prepare early.

Testing levels

  • Unit testing: individual functions or classes.
  • Integration testing: how the parts work together.
  • System testing: the whole system against requirements.
  • Acceptance testing: the customer confirms it meets their need before signing off. Alpha testing happens inside the supplier's organization; beta testing gives pre-release software to a limited set of real users to find issues in real conditions.

Strengths

  • Simple to understand and manage; clear milestones.
  • Strong documentation, useful for regulated or safety-critical work.
  • Easy to estimate and contract when requirements are stable.
  • Suits large teams and distributed vendors with defined hand-offs.

Weaknesses

  • Requirements must be right early; real needs often emerge later.
  • Customers see working software late, so wrong assumptions are found late and fixed at high cost.
  • Testing is squeezed at the end when time is running out.
  • Poor at handling change.

When waterfall fits

Waterfall (or a predictive approach) is a good choice when requirements are fixed and well understood, the technology is proven, regulations demand documentation and sign-offs, or the work is partly physical (hardware). Variations include the V-model, which pairs every development stage with a matching test stage, and incremental versions that deliver several waterfalls in sequence. When requirements are uncertain, agile or iterative approaches reduce risk by delivering and learning in small steps.

Phase durations in code

Suppose a waterfall project splits its effort across phases. Here is how a delay in early phases propagates, since the next phase cannot start until the previous one ends.

Python Waterfall schedule propagation

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

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with input()), it gets the next line from this box.

Late discovery cost

Python Where were defects found?

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

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with input()), it gets the next line from this box.

  • Prototype: build a quick, throwaway version to clarify requirements.
  • Spiral: repeat cycles of planning, risk analysis, engineering and evaluation; strong on risk.
  • Iterative and incremental: deliver in repeated rounds.
  • Agile: short iterations with continuous customer feedback, covered in the later Agile chapter.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. In waterfall, when does the next phase start?

    Phases are sequential, each reviewed before the next begins.
  2. 2. Which requirement is testable?

    Measurable wording lets testers verify it.
  3. 3. Main weakness of waterfall?

    Users see the working product late, so wrong assumptions are expensive to fix.
  4. 4. Beta testing is...

    Beta releases pre-production software to selected users to find real-world problems.

Summary

  • The SDLC covers feasibility, requirements, design, implementation, testing, deployment and maintenance.
  • Waterfall runs the stages in sequence with reviewed deliverables like the SRS.
  • It suits stable requirements and regulated work but handles change poorly.
  • Know the testing levels: unit, integration, system, acceptance (alpha and beta).

Next: PRINCE2 Overview