Skip to content
Tutorials Center
My learning

Topics

Lesson 4 of 50 ยท The SDLC and Process Models

The Software Development Life Cycle

Learn the phases of the software development life cycle, the documents each one produces, and how entry and exit criteria decide when a phase is really done.

The Software Development Life Cycle (SDLC) is the sequence of phases a software product passes through from the first idea to retirement. Every process model in this chapter, from waterfall to spiral, is a different way of arranging the same phases. This lesson looks at the phases themselves: what each one is for, what it produces, and how you decide it is finished.

The SDLC is a way of thinking, not a product you can install, so the phase descriptions and diagrams are text. The runnable example is a Node.js stand-in that checks whether a phase's required outputs exist before the next phase may start. It models the idea of a quality gate; it is not a real project-tracking tool.

The phases and their outputs

The names vary between books (some merge or split phases), but seven are common. Each phase has inputs (what it needs), activities and outputs (called deliverables or artifacts).

flowchart LR
    A["1. Planning"] --> B["2. Requirements analysis"]
    B --> C["3. Design"]
    C --> D["4. Implementation"]
    D --> E["5. Testing"]
    E --> F["6. Deployment"]
    F --> G["7. Maintenance"]
    G -. "new needs" .-> A

Seven common phases; maintenance feeds new needs back into planning, which is why it is called a cycle.

  1. Planning. Decide whether the project is worthwhile and feasible (technical, economic, legal and schedule feasibility). Outputs: a feasibility study, a project plan, an initial budget and risk list.
  2. Requirements analysis. Work out what the system must do. Outputs: a software requirements specification or a prioritized backlog, plus acceptance criteria.
  3. Design. Decide how the system will be built. Outputs: architecture description, interface definitions, data model, and detailed designs (see software design).
  4. Implementation. Write and integrate the code. Outputs: source code under version control, build scripts, unit tests, code review records.
  5. Testing. Verify and validate the product. Outputs: test plan, test cases and results, defect reports, a quality summary.
  6. Deployment. Release to users. Outputs: release package, installation or migration guide, release notes, operations runbook, training material.
  7. Maintenance. Operate and evolve. Outputs: incident records, patches, change requests and new releases, until the system is retired.

What each phase hands over

Requirements Specification and acceptance criteria.
Design Architecture and interfaces.
Implementation Code and unit tests.
Testing Results and defect reports.

A phase without a deliverable is just a feeling of progress.

1 / 2

Entry and exit criteria

A phase is not finished when the calendar says so. Teams use exit criteria (conditions that must be true to leave a phase) and entry criteria (conditions that must be true to start the next). A review that checks them is often called a quality gate or a milestone review.

Examples of useful, checkable criteria:

  • Requirements exit: every requirement has a unique ID, an owner and an acceptance test; the customer has signed the specification; open questions are logged with a due date.
  • Design exit: every requirement is traced to at least one design element; interfaces are documented; a design review found no unresolved major issues.
  • Implementation exit: code compiles in the continuous build; all unit tests pass; code is reviewed; static analysis shows no blocking findings.
  • Testing exit: all planned test cases ran; no open defects of high severity; test coverage target met.
  • Deployment exit: the release was rolled out; smoke tests pass in production; the rollback plan was verified.

Criteria should be objective. "The design is good" is an opinion; "every requirement traces to a design element" can be checked by anyone.

Criteria are sometimes bent under schedule pressure, which is risky: a phase left with known gaps moves its problems downstream, where they cost more (waterfall's cost of late change quantifies this). Agile methods replace phase gates with a per-item definition of done, but the idea is the same: agree in advance what "finished" means.

A phase gate checker

The stand-in below stores, for each phase, the deliverables its exit criteria require and which of them exist. It walks the phases in order and stops at the first gate that fails, reporting what is missing. Run it with the Run button; it executes on the server as Node.js.

Node.js Check phase exit criteria

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 node:readline or process.stdin), it gets the next line from this box.

The first run stops at design because the design review is missing, so the later phases are never judged. After the review is added, the checker moves on and stops at implementation, where unit tests and the code review are still missing. In a real project a gate is a meeting and a decision by people, not a script, but writing the criteria as a list makes disagreements concrete.

Documents and who reads them

Each deliverable has an audience, and writing it for that audience is a skill:

Document Main readers Purpose
Feasibility study Sponsors Decide whether to start
Requirements specification Customers, designers, testers Agree what to build
Design documents Developers, architects Guide the build
Test plan and results QA, managers Show evidence of quality
Release notes Users, support Explain what changed
Runbook Operations Run and fix the system

Documentation costs time, so keep what is read and discard what is not. "Working software over comprehensive documentation" in the agile manifesto is not a ban on documents; it is a reminder that the product matters most.

The cycle never really ends

Maintenance is not a final stage after which nothing happens. Studies of long-lived systems keep showing that most of the effort goes into four kinds of maintenance:

  • Corrective: fixing defects found in use.
  • Adaptive: adjusting to a new operating system, law or external service.
  • Perfective: adding features and improving performance or usability.
  • Preventive: restructuring to avoid future problems (refactoring).

Each of these re-enters the cycle at a different phase: a defect fix may go straight to implementation, while a major new feature needs requirements and design again.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. What is the purpose of exit criteria for a phase?

    Exit criteria make 'done' checkable, so unfinished work does not slip silently into the next phase.
  2. 2. Which of these is an objective exit criterion for design?

    Traceability can be checked by anyone against the documents. The others are opinions or schedule facts.
  3. 3. Fixing a bug found in production is which kind of maintenance?

    Corrective maintenance repairs defects. Adaptive responds to environment changes, perfective improves or adds, preventive restructures.
  4. 4. In the gate checker example, why were the testing phase gate and later gates not reported in the first run?

    The function returns as soon as it finds a failing phase, modelling the idea that later phases may not start until earlier gates are passed.

Summary

  • The SDLC phases are planning, requirements analysis, design, implementation, testing, deployment and maintenance; process models arrange them differently.
  • Each phase should produce concrete deliverables such as a specification, an architecture, tested code and release notes.
  • Entry and exit criteria make "done" objective; a quality gate checks them before work moves on.
  • Maintenance (corrective, adaptive, perfective, preventive) usually consumes most of the lifetime effort and feeds new work back into earlier phases.

Next: The Waterfall Model.