Chapter 03 of 32

Software Development Life Cycle (SDLC)

Building a house follows a natural order: decide what you need, check the budget, get an architect's plan, lay the foundation, build, inspect, move in, and then repair and renovate over the years. Nobody starts by buying paint.

Software also goes through a natural sequence of stages from "we have an idea" to "the system is retired". This sequence is called the Software Development Life Cycle (SDLC). In Introduction to Software Engineering we said software engineering replaces code-and-fix with a disciplined process; the SDLC is the backbone of that process. In this chapter we study each SDLC phase in detail (its purpose, activities and outputs), walk through a complete example, and get a first look at the different SDLC models that the following chapters explain one by one.


What Is the SDLC?

Software Development Life Cycle (SDLC): the series of well-defined phases through which a software product passes, from its conception, through development and use, until it is retired. Each phase has specific activities and produces specific outputs (deliverables) that become the inputs of later phases.

A closely related term is software process model (or SDLC model): a description of how the phases are arranged in time. Do they happen once, in strict order (Waterfall)? In repeated cycles (Iterative, Spiral)? In short sprints (Scrum)? The phases are roughly the same in every model; the ordering and repetition are what differ.

Why Define a Life Cycle?

  • Shared understanding: everyone on the team knows what happens now, what comes next, and who is responsible.

  • Planning and tracking: managers can define milestones ("design approved", "system testing complete") and check real progress, which is otherwise invisible in software.

  • Quality: each phase has entry and exit criteria, so work is reviewed before the next phase builds on it.

  • Discipline in large teams: without agreed phases, different people do different things at the same time, and the result is chaos.

  • Contracts: outsourced and government projects often tie payments to phase deliverables.

Entry and Exit Criteria

A well-defined phase states:

  • Entry criteria: what must be ready before the phase can begin (for example, "SRS is signed off" before design).

  • Tasks: what is done in the phase.

  • Verification: how the outputs are checked (reviews, inspections, tests).

  • Exit criteria: what must be true for the phase to be complete (for example, "design document reviewed and approved").

This pattern is sometimes summarised as ETVX (Entry, Task, Verification, eXit).


The Phases of the SDLC

  +-------------------------+
  | 1. Feasibility study    |  Is it worth doing? Can we do it?
  +-------------------------+
              |
              v
  +-------------------------+
  | 2. Requirements         |  WHAT should the system do?
  |    analysis & spec      |  --> SRS document
  +-------------------------+
              |
              v
  +-------------------------+
  | 3. Design               |  HOW will it be built?
  |    (high- and low-level)|  --> design document
  +-------------------------+
              |
              v
  +-------------------------+
  | 4. Coding & unit testing|  Build each module and test it alone
  +-------------------------+
              |
              v
  +-------------------------+
  | 5. Integration & system |  Combine modules, test the whole system
  |    testing              |  against the SRS
  +-------------------------+
              |
              v
  +-------------------------+
  | 6. Deployment           |  Install, migrate data, train users
  +-------------------------+
              |
              v
  +-------------------------+
  | 7. Maintenance          |  Fix, adapt, enhance ... until retirement
  +-------------------------+

Different books split or name the phases slightly differently (some merge feasibility into requirements, some separate "testing" from "integration"), but these seven cover everything. Let us go through each one.

1. Feasibility Study

Purpose: decide whether the project is worth doing at all, before spending serious money.

Activities:

  • Understand the problem at a high level and the client's goals.

  • Identify possible solution strategies (build, buy, modify an existing system).

  • Check technical feasibility (do we have the technology and skills?), economic feasibility (do benefits exceed costs?), operational feasibility (will users actually use it?), plus legal and schedule feasibility.

Output: a feasibility report with a go / no-go recommendation and a preferred solution approach. Details are in Feasibility Study.

2. Requirements Analysis and Specification

Purpose: understand exactly what the customer needs, and write it down precisely.

Activities:

  • Requirements gathering (elicitation): interviews, questionnaires, workshops, observing users, studying existing systems and documents.

  • Analysis: remove ambiguities, contradictions and gaps. Ask "what should happen if...?" questions.

  • Specification: write the Software Requirements Specification (SRS), covering functional requirements (what the system does), non-functional requirements (performance, security, usability...) and constraints.

  • Validation: review the SRS with the customer and get sign-off.

Output: the approved SRS. It acts as the contract between customer and developer and as the basis for design and for system/acceptance testing. See Requirements Engineering and Software Requirements Specification (SRS).

Why this phase is so important: an error in requirements spreads into the design, code, tests and manuals built on it. The later it is found, the more has to be redone.

3. Design

Purpose: decide how the system will meet the requirements, i.e. transform the SRS into a structure that can be coded.

  • High-level design (HLD) / architectural design: split the system into major components or modules, decide how they interact, and choose the architecture (for example, client-server, layered, microservices), technologies and database design.

  • Low-level design (LLD) / detailed design: for each module, define data structures, algorithms, class designs, function signatures and interfaces in enough detail to code.

Output: the Software Design Document (SDD), often with UML diagrams, data flow diagrams, database schemas and API definitions. See Software Design Principles, Modularity, Coupling & Cohesion, UML Diagrams and Data Flow Diagrams.

4. Coding and Unit Testing

Purpose: translate the design into source code, and check each unit on its own.

  • Developers write code following coding standards (naming, formatting, error handling, comments).

  • Code reviews catch defects and share knowledge.

  • Unit testing: each module, function or class is tested in isolation, often with automated test frameworks (JUnit, pytest, Google Test).

  • All code is kept in version control (Git).

Output: tested, reviewed source code for each module, plus unit test cases and results.

5. Integration and System Testing

Purpose: combine the modules into a complete system and check it against the SRS.

  • Integration testing: modules are combined step by step (top-down, bottom-up, sandwich, or all at once) and their interfaces are tested.

  • System testing: the complete system is tested against all functional and non-functional requirements: features, performance, load, security, usability, recovery.

  • Acceptance testing: the customer (or users) test the system to decide whether to accept it. For products, this may include alpha testing (by users at the developer's site) and beta testing (by real users in their own environment).

Output: a system ready for release, along with test plans, test reports and a list of known issues. See Software Testing Fundamentals and Levels of Testing.

6. Deployment

Purpose: make the system available to its users in the real (production) environment.

  • Install and configure the software on production servers, app stores or user machines.

  • Migrate data from the old system, if any.

  • Train users, provide manuals and support channels.

  • Choose a rollout strategy: everything at once, a pilot at one branch first, a phased rollout to a percentage of users, or running old and new systems in parallel for a while.

In modern teams deployment is usually automated and happens frequently; see DevOps & CI/CD.

7. Maintenance

Purpose: keep the software useful after release, for as long as it is used.

Type

What it does

Example

Corrective

Fixes defects found after release

Fixing a wrong fine calculation in a library system

Adaptive

Adapts the software to a changed environment

Supporting a new Android version or new tax rules

Perfective

Adds or improves features and performance as users ask

Adding e-book lending

Preventive

Improves structure to prevent future problems

Refactoring messy code, updating old libraries

For long-lived systems, maintenance usually consumes more effort than the original development; many textbooks quote figures of 60% or more of total life-cycle cost. That is why every earlier phase should aim for maintainable software. Finally, every system is eventually retired: data is archived or migrated and the system is switched off. Maintenance is covered in Software Maintenance & Reengineering.


Phase Summary Table

Phase

Key question

Main output

Main people

Feasibility study

Should we build it?

Feasibility report

Analysts, managers, client

Requirements

What should it do?

SRS

Business analysts, client, users

Design

How will it work?

Design document (HLD, LLD)

Architects, senior developers

Coding & unit testing

Does each piece work?

Source code, unit tests

Developers

Integration & system testing

Does the whole system meet the SRS?

Tested system, test reports

Testers, developers, client

Deployment

Can users start using it?

Running production system, manuals

Ops/DevOps, trainers

Maintenance

Does it keep working and stay useful?

Patches, new releases

Maintenance team


Worked Example: A College Library Management System

Let us follow one small project through all phases. A college wants to replace its paper registers with software for issuing and returning books.

Phase 1: Feasibility

  • Technical: a web application with a relational database; the college IT team knows Java and MySQL. Feasible.

  • Economic: development and hosting costs are compared with the time librarians save and the reduction in lost books. Benefits exceed costs over three years. Feasible.

  • Operational: librarians are willing; students already use the college portal. Feasible.

Decision: go ahead.

Phase 2: Requirements (extract from the SRS)

FR-1  The librarian shall register a book with ISBN, title, author and
      number of copies.
FR-2  A student shall be able to search books by title, author or ISBN.
FR-3  The librarian shall issue a book to a student; a student may hold
      at most 3 books at a time.
FR-4  On return after the due date (14 days), the system shall compute a
      fine of Rs 2 per day late.
NFR-1 Search results shall be shown within 2 seconds for 95% of queries
      with 500 concurrent users.
NFR-2 Only librarians may issue or return books (role-based login).

Notice that every requirement is specific and testable. "The system should be fast" would not be.

Phase 3: Design

HLD:  Browser  -->  Web server (Java, REST API)  -->  MySQL database
      Modules: Auth, Catalogue, Circulation (issue/return), Fines, Reports

LLD (Circulation module, part):
      issueBook(studentId, copyId):
          if activeLoans(studentId) >= 3 -> reject "limit reached"
          if copy not available           -> reject "not available"
          create Loan(studentId, copyId, issueDate = today,
                      dueDate = today + 14 days)
      fine(daysLate) = max(0, daysLate) × 2

Phase 4: Coding and Unit Testing

A developer implements the fine rule and writes unit tests for boundary cases, chosen straight from FR-4:

Returned on day | Days late | Expected fine
       14       |     0     |   Rs 0     (exactly on due date)
       15       |     1     |   Rs 2
       20       |     6     |   Rs 12
       10       |     0     |   Rs 0     (early return, never negative)

Phase 5: Integration and System Testing

  • Integration: does Circulation correctly call Catalogue to mark a copy unavailable, and Fines to record a fine?

  • System: can a student hold a 4th book? (FR-3 says no.) Does search meet NFR-1 under a load test with 500 simulated users? Can a student account call the issue API directly? (NFR-2 says no.)

  • Acceptance: librarians use the system for a week on test data and approve it.

Phase 6: Deployment

Existing book records are imported from spreadsheets, librarians are trained, and the system runs alongside the paper register for two weeks (parallel run) before the register is retired.

Phase 7: Maintenance

  • Corrective: a bug where fines were charged on Sundays (when the library is closed) is fixed.

  • Adaptive: the system is moved to a new cloud server.

  • Perfective: SMS reminders two days before the due date are added.


Verification vs Validation

Two terms appear throughout the SDLC, and in many exam questions. Barry Boehm summarised them neatly:

Verification

Validation

Question

"Are we building the product right?"

"Are we building the right product?"

Checks against

The specification and the outputs of the previous phase

The customer's real needs and expectations

Typical methods

Reviews, walkthroughs, inspections, static analysis, unit and integration tests

System and acceptance testing, prototypes, beta testing, user demos

When

At the end of every phase

Mainly at the end, and whenever users can see working software

Software can pass verification (it matches the SRS perfectly) and still fail validation (the SRS itself described the wrong thing). That is why models with early user feedback, such as Prototyping Model and agile methods, exist.


The Cost of Late Defects

A defect costs more to fix the later it is discovered, because more work has been built on top of it. A requirements mistake found during a review only needs a document change. The same mistake found after release may require changing the design, code, tests, manuals and data, and redeploying to every user.

Relative cost
to fix a defect
   ^
   |                                              ###
   |                                              ###
   |                                    ###       ###
   |                          ###       ###       ###
   |          ###    ###      ###       ###       ###
   |   ###    ###    ###      ###       ###       ###
   +---Req----Design-Code----Test-----Accept----After release--->
                  phase in which the defect is found

Boehm and Basili's widely cited 2001 summary of defect research reported that, for large systems, finding and fixing a problem after delivery is often around 100 times more expensive than finding it during requirements or design (the ratio is much smaller for small, simple systems). This one fact explains much of the SDLC: reviews at the end of each phase exist to catch errors where they are introduced, which is called phase containment (more in Waterfall Model).


SDLC Models: A Preview

Different projects arrange the phases differently. The following chapters cover each model in detail; here is the map:

Model

Core idea

Best suited for

Waterfall

Phases done once, in strict sequence

Small or well-understood projects with stable requirements

Iterative & Incremental

Build the system in pieces / repeated cycles, delivering working parts early

Projects where early delivery helps and requirements evolve

Prototyping

Build a quick model to clarify unclear requirements

Unclear requirements, UI-heavy systems

Spiral

Repeated cycles driven by risk analysis

Large, high-risk projects

V-Model

Each development phase paired with a matching test level

Safety-critical systems with strict verification

Agile (Scrum, Kanban, XP)

Short iterations, working software, close customer collaboration

Changing requirements, product development

DevOps & CI/CD

Automate build, test and deployment; development and operations work as one

Web and cloud products released frequently

How to Choose a Model

Ask these questions:

  1. How clear and stable are the requirements? Very stable → Waterfall or V-Model. Unclear → Prototyping or Agile.

  2. How big and risky is the project? High technical or business risk → Spiral or iterative models.

  3. Is early delivery valuable? Yes → Incremental or Agile.

  4. Is it safety-critical or heavily regulated? Yes → V-Model, with strong documentation and traceability.

  5. How available is the customer? Agile needs frequent customer involvement; Waterfall needs it mostly at the start and end.

  6. How experienced is the team with the domain and technology?

Standards

The international standard for software life cycle processes is ISO/IEC/IEEE 12207 (first published in 1995; the current edition is 12207:2026). It defines the processes an organisation can use (agreement, organizational project-enabling, technical management and technical processes) but deliberately does not force any particular life cycle model. Teams choose a model and map it onto these processes.


Common Mistakes Students Make

  • Treating SDLC and Waterfall as the same thing. The SDLC is the set of phases; Waterfall is just one way of arranging them.

  • Forgetting maintenance as a phase, or thinking the life cycle ends at deployment.

  • Mixing up HLD and LLD. HLD = modules and their interactions; LLD = internal logic, data structures and interfaces of each module.

  • Writing untestable requirements such as "user friendly" or "fast" without measurable criteria.

  • Swapping verification and validation. Verification: product right (matches spec). Validation: right product (meets real needs).


Interview / Exam Questions

1. What is the SDLC? List its phases.

The SDLC is the sequence of phases a software product goes through from conception to retirement: feasibility study, requirements analysis and specification, design, coding and unit testing, integration and system testing, deployment, and maintenance.

2. What is the difference between an SDLC and an SDLC model?

The SDLC describes the phases (what work is done). An SDLC model (process model) describes how those phases are organised in time: once in sequence (Waterfall), repeated in cycles (Iterative, Spiral), or in short time-boxed iterations (Scrum).

3. Which phase produces the SRS, and why is it important?

The requirements analysis and specification phase. The SRS is the agreement between customer and developer on what will be built, and it is the basis for design, estimation and system/acceptance testing.

4. Distinguish high-level design from low-level design.

HLD defines the architecture: major modules, their responsibilities, interactions, technologies and database design. LLD defines each module's internals: algorithms, data structures, classes, function signatures and interface details, enough to write code directly.

5. Name the four types of maintenance with an example each.

Corrective (fix a reported bug), adaptive (support a new OS version or new tax law), perfective (add a feature users requested or improve performance), preventive (refactor code or update libraries to avoid future problems).

6. Verification vs validation?

Verification checks that each phase's output conforms to its specification ("building the product right"), using reviews, inspections and tests. Validation checks that the final product meets the customer's actual needs ("building the right product"), using acceptance tests, prototypes and user feedback.

7. Why is it cheaper to fix defects early?

Later phases build on earlier outputs. A requirement or design error found late forces rework of design, code, tests and documentation, and possibly redeployment to users. Found early, it may need only a document change.


Summary

  • The SDLC is the sequence of phases from idea to retirement; each phase has activities, outputs, and entry/exit criteria.

  • Phases: feasibility → requirements (SRS) → design (HLD, LLD) → coding & unit testing → integration & system testing → deployment → maintenance.

  • Maintenance (corrective, adaptive, perfective, preventive) often costs more than initial development.

  • Verification = building the product right; validation = building the right product.

  • Defects are much cheaper to fix in the phase where they are introduced.

  • SDLC models (Waterfall, Iterative, Prototyping, Spiral, V, Agile) arrange these phases differently; choose based on requirement stability, risk, size and customer availability.

The oldest and simplest way to arrange the phases is to do them one after another, exactly once. That is the Waterfall Model, our next chapter.