System Design

What are the 7 phases of the SDLC?

The 7 SDLC phases are planning, requirements, design, development, testing, deployment and maintenance. Here's what each involves, with an embedded view.

On this page
  1. The 7 phases at a glance
  2. Each phase in more detail
  3. Why some sources list 5 or 6 phases
  4. The phases in different SDLC models
  5. How the phases look on an embedded project
  6. Common mistakes across the phases

The 7 phases at a glance

The software development life cycle (SDLC) is a structured way to take software from an idea to a working product and keep it working afterwards. The seven phases most commonly listed are:

  1. Planning: decide whether the project is worth doing, and set its scope, budget, schedule and risks.
  2. Requirements analysis: work out and document exactly what the software must do and how well it must do it.
  3. Design: decide how the software will be built: its architecture, components, interfaces and data.
  4. Development: write the code according to the design.
  5. Testing: check that the software works correctly and meets the requirements.
  6. Deployment: release the software to its users or install it in its target environment.
  7. Maintenance: fix bugs, apply security updates and add improvements over the software’s working life.

Each phase produces outputs that feed the next, such as a project plan, a requirements specification, design documents, source code, test reports and release notes.

Each phase in more detail

1. Planning

Planning answers “should we build this, and what will it take?” Typical activities include:

  • Defining the problem and the project’s goals.
  • Feasibility checks: technical (can it be built?), financial (can we afford it?) and operational (will people use it?).
  • Rough estimates of cost, effort and timeline.
  • Identifying major risks and how to reduce them.
  • Agreeing who is responsible for what.

Some sources split out a separate “feasibility study” phase; others fold it into planning.

2. Requirements analysis

This phase captures what the system needs to do. Requirements are usually split into:

  • Functional requirements: what the software does, such as “log a temperature reading every five minutes.”
  • Non-functional requirements: how well it does it, such as response time, reliability, security, usability and resource limits.

The result is often written up as a Software Requirements Specification (SRS). Clear, testable requirements matter because mistakes here are usually the most expensive to fix later.

3. Design

Design turns requirements into a plan for building the software:

  • High-level design: the overall architecture, the main components and how they communicate.
  • Detailed design: the internal structure of each component, data structures, algorithms and interfaces.

Design also covers technology choices, such as programming language, frameworks, operating system and third-party libraries.

4. Development

Also called coding or implementation, this is where developers write the software. Good practice includes following coding standards, using version control, reviewing each other’s code and writing unit tests alongside the code.

5. Testing

Testing checks the software against its requirements and looks for defects. It usually happens at several levels: unit testing, integration testing, system testing and acceptance testing by users or customers. Security, performance and regression testing are also common. In many modern teams, a lot of testing runs automatically on every code change rather than only at the end.

6. Deployment

Deployment puts the software into real use. Depending on the product, that might mean releasing to an app store, installing on servers, rolling out to an organisation in stages, or programming it into devices on a production line. Release notes, user documentation and training often accompany this phase.

7. Maintenance

Software usually spends far longer in use than in development. Maintenance covers bug fixes, security patches, adapting to new hardware or operating systems, performance improvements and new features. Eventually it also includes retiring the software.

Why some sources list 5 or 6 phases

There is no single official number of SDLC phases. Different textbooks, companies and standards group the same activities differently. This table shows how common versions line up:

7-phase version Common 6-phase version Common 5-phase version
Planning Planning Requirements and planning
Requirements analysis Analysis Requirements and planning
Design Design Design
Development Development Implementation
Testing Testing Testing
Deployment Deployment and maintenance Deployment and maintenance
Maintenance Deployment and maintenance Deployment and maintenance

The underlying work is the same; only the grouping changes. If you’re answering an exam or interview question, use the version your course or organisation uses.

The phases in different SDLC models

The seven phases describe what happens. An SDLC model describes how the phases are arranged in time.

Waterfall

Phases run one after another, each finishing before the next starts. Waterfall is simple to plan and manage, but changes late in the project are costly because earlier phases have to be revisited.

V-model

The V-model pairs each development phase with a matching test phase: requirements with acceptance testing, architecture with integration testing, detailed design with unit testing. It is common in safety-critical industries such as automotive, medical and aerospace, because it makes it easy to show that every requirement has been tested.

Agile and iterative

Agile methods such as Scrum run through planning, design, development and testing repeatedly in short cycles, delivering working software in small increments. The phases still exist, but each one happens many times on a small scale rather than once on a large scale. The spiral model, an older iterative approach, adds an explicit risk-analysis step to each cycle.

How the phases look on an embedded project

On embedded systems, where software runs on dedicated hardware, the same seven phases apply but with some important differences:

  • Planning has to account for hardware costs, component availability and manufacturing, not just developer time.
  • Requirements include physical constraints such as power consumption, memory size, operating temperature, response deadlines and certification needs.
  • Design includes deciding which functions go in hardware and which in software, and choosing the processor.
  • Development happens alongside circuit board design, often starting on development boards before the custom hardware exists.
  • Testing includes the hardware: integration on real boards, hardware-in-the-loop rigs, and environmental and electromagnetic compatibility tests.
  • Deployment means programming firmware into devices during manufacturing, and possibly setting up a secure way to update them later.
  • Maintenance can last a decade or more, and may involve dealing with components that go obsolete.

Our article on the embedded system development life cycle covers this in depth, and the introduction to embedded system design walks through the design flow step by step. For more on the testing phase specifically, see testing and validating embedded software.

Common mistakes across the phases

  • Rushing requirements. Vague or missing requirements lead to rework later, when changes cost more.
  • Treating testing as a final step. Defects found late are harder and more expensive to fix. Testing works better when it starts early and runs continuously.
  • Ignoring maintenance in the plan. Updates, support and security patches need budget and people after release.
  • Following a model rigidly. No model fits every project. Many teams mix approaches, for example a V-model structure for safety documentation with agile iterations inside it.
  • Poor communication between phases. When the people writing requirements, designing, coding and testing don’t talk, assumptions get lost between handovers.

The complete guide to system design

Introduction to Embedded System Design: The Design Flow
Read the guide

Keep exploring

Guides from other topics

All topics →