Skip to content
Tutorials Center
My learning

Topics

Lesson 4 of 29 ยท Agile Basics

The software development life cycle, its models and requirements gathering

Learn the phases of the software development life cycle, compare waterfall, V-model, spiral, prototyping and agile models, and gather and write requirements with an SRS outline.

Agile did not appear from nowhere. It is one answer to an older question: how should a team organize the work of building software? The general frame for that question is the software development life cycle (SDLC), a set of phases every project passes through whether or not anyone names them. Different SDLC models arrange those phases differently, and knowing them lets you explain why Scrum looks the way it does and when an older, more plan-driven model is still the better choice.

This lesson covers the phases, the main models (waterfall, V-model, spiral, prototyping, iterative and agile), the techniques used to gather requirements, and the outline of a software requirements specification (SRS). Jira cannot run here, so the interactive parts are small JavaScript stand-ins that model the ideas.

The phases of the SDLC

Whatever the model, the same activities occur:

  1. Requirement analysis. Find out what is needed, by whom and why. The result is a list of needs and constraints.
  2. Planning and feasibility. Estimate cost, time, risks and whether the project is worth doing.
  3. Design. Decide the architecture, data model, interfaces and user experience.
  4. Implementation (coding). Build the software from the design.
  5. Testing. Check that it meets the requirements and find defects. The matching process for testers is the software testing life cycle: analyze requirements, plan tests, write cases, set up an environment, execute, report and close.
  6. Deployment. Release it to users: install, migrate data, switch on.
  7. Maintenance. Fix bugs, adapt to new platforms, add improvements. For long-lived software this phase is by far the longest and most costly.

The phases are the same; what differs between models is order, size of the batch and feedback speed.

Waterfall

In the waterfall model each phase finishes completely before the next begins: requirements, design, implementation, testing, deployment, maintenance. Documents are the handoff between phases, and a phase is signed off before moving on.

Strengths: easy to understand and manage, clear milestones, good documentation, a natural fit when requirements are fixed and well understood, or when regulations demand a documented trail.

Weaknesses: changes are expensive because the customer sees working software late; testing happens at the end, when defects are costliest; early mistakes in requirements travel all the way down.

V-model

The V-model is waterfall with testing planned from the start. Each development phase on the left side of the V has a matching test level on the right:

Left side (building) Right side (verifying)
Business requirements Acceptance testing
System requirements System testing
Architecture and high-level design Integration testing
Detailed design Unit testing

Coding sits at the bottom of the V. The idea is that you write the test plan for each level while you write the matching specification, which catches ambiguous requirements early. It is still sequential, so it shares waterfall's weakness with change. The vocabulary it introduced, verification (are we building the product right?) and validation (are we building the right product?), is used everywhere.

Prototyping

When users cannot say exactly what they want until they see something, build a prototype: a quick, partial version that shows the idea. Users react, the team learns, and the requirements improve. Prototypes can be throwaway (discarded after learning) or evolutionary (grown into the product). The risk is that a quick prototype becomes the product without ever being redesigned, or that users believe a prototype is nearly finished.

Iterative and incremental

An iterative approach repeats the cycle many times, improving the product each time. An incremental approach delivers it in usable slices. Combined, a team builds a thin working version first and then grows it. This is the bridge from waterfall to agile: smaller batches, earlier feedback.

Spiral

The spiral model, proposed by Barry Boehm, repeats four steps in loops: set objectives, identify and resolve risks, develop and test, and plan the next loop. Each loop builds a more complete version. It is called a meta model because it can include other models inside a loop (a prototype in the first loop, a waterfall-like build in a later one). It fits large, risky, expensive projects, where risk analysis pays for itself, and is heavy for small ones.

Agile

Agile methods (see What Is Agile? and Scrum, Kanban, XP and Lean Compared) take iteration to the extreme: short cycles of a week or a few weeks, each ending with working software and feedback, with requirements discovered and reordered continuously. Planning, design, coding and testing happen inside every cycle instead of in separate phases.

The same project in four shapes

The stand-in below counts how long a customer waits to see working software, and how much work is at risk of being wrong, under different models. The numbers are invented to illustrate the shape; real projects vary widely.

JS When does the customer first see working software?

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

No output.

Choosing a model

No model is universally best. Ask a few questions:

Question Points towards
Are requirements stable and well understood? Waterfall or V-model
Is there heavy regulation or a required document trail? V-model, or agile with strict documentation
Do users need to see it to know what they want? Prototyping or agile
Is the project large with major technical or business risks? Spiral
Is the product long-lived and changing, with direct access to users? Agile
Can the team deliver in small slices and release often? Agile

Many real organizations mix: a hardware project with agile software teams, or a regulated system developed in sprints with documentation produced alongside.

JS A small model chooser

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

No output.

Gathering requirements

Every model needs requirements, so learning to collect them well is the most portable skill here. A requirement says what the system must do (functional) or how well it must do it (non-functional, such as speed, security, accessibility). The work follows steps:

  1. Identify stakeholders: users, customers, operators, support, legal, anyone affected.
  2. Analyze them: who has influence, who has the most at stake, who has conflicting goals?
  3. Define the problem before the solution.
  4. Extract requirements with techniques such as the ones below.
  5. Validate and verify: read them back to stakeholders, check for conflicts and gaps, and make each one testable.

Common techniques:

  • Interviews: one-to-one conversations that reveal detail and context.
  • Surveys and questionnaires: reach many people cheaply, but only answer the questions you thought to ask.
  • Workshops: group sessions that resolve disagreements fast.
  • Observation: watch people do the work; they often describe it differently from how they do it.
  • Document analysis: study existing forms, reports and system documentation.
  • Prototyping and wireframes: show something and collect reactions.
  • User stories: short statements of need (see User Stories and Acceptance Criteria).

Typical failure causes are unclear objectives, ambiguous wording, too little user involvement, and the opposite problem of writing so much documentation that nobody reads it. Good requirements are clear, testable, necessary, feasible and traceable to a need.

The software requirements specification (SRS)

Plan-driven projects often record requirements in an SRS. A common outline:

  1. Introduction: purpose, scope, definitions, references.
  2. Overall description: product perspective, user classes, operating environment, assumptions and constraints.
  3. Specific requirements: functional requirements (grouped by feature), external interface requirements, and non-functional requirements (performance, security, reliability).
  4. Appendices: glossary, models, open issues.

Compare the BRS (business requirements specification), written in the language of the business ("reduce checkout time"), with the SRS, which turns those into precise statements for the team ("the system shall display the order total within 2 seconds"). Agile teams replace much of this with a prioritized backlog, acceptance criteria and conversation, but the thinking is the same.

Check your understanding

Quick check ยท 5 questions

of 5 answered You scored / 5 ยท perfect!

  1. 1. Which model pairs each development phase with a matching level of testing?

    In the V-model, requirements pair with acceptance tests, design with integration tests, and so on.
  2. 2. What is the distinguishing feature of the spiral model?

    Each loop sets objectives, identifies and resolves risks, builds and tests, then plans the next loop.
  3. 3. Which description is verification rather than validation?

    Verification checks conformance to the specification; validation checks that the specification meets real needs.
  4. 4. Users cannot describe what they want until they see something. Which approach helps most?

    A prototype lets users react to something concrete, which uncovers real requirements.
  5. 5. Which is a non-functional requirement?

    Non-functional requirements describe qualities such as speed, security or accessibility, not features.

Summary

  • Every project passes through requirements, planning, design, implementation, testing, deployment and maintenance; models differ in order, batch size and feedback speed.
  • Waterfall and the V-model are sequential and suit stable, regulated work; prototyping learns by showing; spiral manages risk loop by loop; agile delivers small slices continuously.
  • Choose a model by stability of requirements, regulation, risk, need for user feedback and release frequency.
  • Gather requirements by identifying stakeholders and using interviews, surveys, workshops, observation, documents and prototypes, then validate them.
  • An SRS records functional and non-functional requirements precisely; agile teams capture the same thinking in backlogs and acceptance criteria.

Next: Scrum at a Glance.