Not sure which lesson to do first? Find your level and get a plan →

CS Thinking · Software Design & Development · Grade 9-12

Software Development Life Cycle

The structured process of planning, creating, testing, deploying, and maintaining software, typically following phases: requirements gathering, design, implementation (coding), testing, deployment, and maintenance.


Quick Answer

The structured process of planning, creating, testing, deploying, and maintaining software, typically following phases: requirements gathering, design, implementation (coding), testing, deployment, and maintenance. Use it to decide what should happen next on a project and what each phase must hand to the next: requirements produce a spec, design produces a plan, coding produces code ready for testing. Waterfall runs the phases once, in order; agile runs all of them in short cycles of one or two weeks, so users see working software early and the plan changes as they react.

Why This Matters

The SDLC explains why a problem costs more the later it is found. A missing requirement caught while writing the spec is a sentence to change; the same gap found after release means redesign, recoding, retesting and an update for every user. Knowing the phases also lets you pick a process that fits: waterfall for fixed rules like payroll, agile when users' needs are still unclear.

Intuitive Explanation

Follow a school club's event sign-up app from idea to retirement. Requirements: the club leaders say sign-ups must stop at 30, with a waiting list after that. Design: sketch the screens and decide how the waiting list works. Implementation: write the code. Testing: sign up 30 people, then a 31st, and check that the 31st lands on the waiting list. Deployment: put it online for the whole school. Maintenance: a year later, fix a time-zone bug and add a new kind of event. Each phase produces something the next phase depends on.

The phases are kinds of work, not always a fixed timetable. In the waterfall model you finish each phase before starting the next, which suits projects whose requirements are set by law or contract. In agile, a two-week sprint contains a little of every phase: plan a few features, build them, test them, show them to users and adjust. Agile still has structure, with sprint planning, reviews and retrospectives; what it drops is the single plan made up front.

Not every development story is the SDLC. Fixing one typo on a live website is a single maintenance task, not a pass through six phases, and debugging is an activity inside testing and maintenance, not a life cycle of its own. You are dealing with the SDLC when the question is about the order of phases, what moves between them, or which model to choose for a whole project.

Think of it like this. Developing software resembles launching a new dish at a restaurant: ask diners what they want, write the recipe, cook a test batch, let staff taste it, add it to the menu, then tweak it from comments. Waterfall perfects the dish before serving anyone; agile serves small tasting plates every week. Unlike a dish, released software reaches every user at once, mistakes included.

Core idea. The SDLC provides structure so that complex software can be built reliably. Different models (waterfall, agile, spiral) emphasize different approaches.


When to Use

Use the SDLC when a question asks which phase a task belongs to, what a phase must produce before the next can start, or whether waterfall or agile fits a project. Clues include a project timeline, a team planning releases, or a bug found late and its cost. If the question is about the single document that says what the system must do, use Design Specification; if it is about recording changes to code over time, use Version Control.

Tip. Ask: Is the question about which phase a software project is in, or what each phase hands to the next?

How to Recognize It

Place the activity on a timeline of the whole project, from finding out what users need to fixing the released product.

  1. Does the situation describe a stage of the whole project, such as gathering needs, building, testing or releasing?

    Yes means the life cycle frames it. A question about one activity in depth, such as how to choose test inputs, belongs to that activity's own concept, like Testing.

  2. Is the team choosing between finishing every phase once, in order, and repeating short cycles?

    Yes means it is about the model, waterfall or agile. Waterfall suits fixed, well-understood requirements; agile suits needs that will change once users try the product.

  3. Has the software already been released to users?

    Yes means the project is in the maintenance phase, the topic of Code Maintenance. No means an earlier phase: requirements, design, coding or testing.

  4. Is the question about the steps a program carries out when it runs?

    Yes means it is about an Algorithm; the life cycle describes the steps people follow to build a program, not the steps the program performs.

Software Development Life Cycle vs Design Specification vs Testing vs Code Maintenance

Specifications, testing and maintenance are each one part of the life cycle, so a question about one phase is often answered with the whole cycle, or the reverse. Ask whether the question is about the order of all the phases or the work inside just one.

Software Development Life Cycle

Meaning
The software development life cycle is the full sequence of phases a project moves through, from requirements to maintenance.
Key test
About the order of phases and the handovers across the whole project.
Example
A team plans an app, designs it, codes it, tests it, releases it and keeps patching it.

Design Specification

Meaning
A design specification is the document produced in the requirements phase, saying what the software must do.
Key test
One document from an early phase, not the process around it.
Example
'The bus app shows each bus's location, updated every 15 seconds' is one line in the specification.

Testing

Meaning
Testing runs the software with known inputs to check that its outputs match what was required.
Key test
One phase's work: checking results against the requirements.
Example
Testers enter a route with no buses running and check the app says so instead of crashing.

Code Maintenance

Meaning
Code maintenance is the work of fixing, adapting and improving software after it has been released.
Key test
Happens after release, on code people already use.
Example
An update months after launch fixes the crash on older phones and adds a new route.

Formula & Notation

Worked Examples

Example 1 — Place each task in its phase

Easy

A team is building a bus-tracking app for a school. Put each task in its SDLC phase: (1) interviewing students about which stops they use; (2) a tester finding, before release, that arrival times are wrong when a bus is more than 20 minutes late; (3) choosing a map screen and a list screen; (4) releasing version 1.0 to the app store; (5) writing the code that reads GPS positions; (6) updating the app after the city renames a route.
Show the steps and the answer
  1. Task 1 is Requirements.

    Learning what users need comes before any decision about screens or code.

  2. Task 3 is Design and task 5 is Implementation.

    Choosing screens decides how the app will meet the needs; writing the GPS code builds that design.

  3. Task 2 is Testing.

    The tester compared the code's output with the expected arrival times before users ever saw it.

  4. Task 4 is Deployment and task 6 is Maintenance.

    Release puts the app in users' hands; changing it because the world around it changed comes after release.

Answer: 1 Requirements, 3 Design, 5 Implementation, 2 Testing, 4 Deployment, 6 Maintenance.

Takeaway: Place a task by what it produces: needs, a plan, code, test results, a release, or a change to software already in use.

Example 2 — Waterfall or agile?

Standard

Two projects: (A) a payroll program that must apply this year's tax rules, which are published in full and fixed for 12 months; (B) a study app for Year 9 students, where nobody knows yet whether students want flashcards, quizzes or a timer. Which life-cycle model suits each, and why?
Show the steps and the answer
  1. For A, check how stable the requirements are: the tax rules are complete and fixed.

    With requirements that will not change, a waterfall plan can be finished once and tested against the rules exactly.

  2. Weigh the cost of an error in A: a wrong tax amount is a legal problem from the first payday.

    Waterfall's full testing phase before a single release suits software that must be right on day one.

  3. For B, check the requirements: the main features are unknown.

    A full up-front plan would be a guess. Agile builds a small version, say flashcards only, in a two-week sprint, lets students try it, and plans the next sprint from their reactions.

Answer: A suits waterfall (stable, fully known requirements that must be correct at release). B suits agile (needs unknown, so build small and get feedback every sprint).

Takeaway: Let the requirements choose the model: stable and known favours waterfall, uncertain or changing favours agile.

Example 3 — Find the mistake: coding first

Application

Zoe's team has 6 weeks to build a homework planner. Zoe says: 'Planning is a waste. We'll code for all 6 weeks and test at the end if there's time.' In week 5 they learn that teachers needed to post tasks too, which their code cannot do. Find the mistake in Zoe's plan and propose a better schedule.
Show the steps and the answer
  1. Name the phases Zoe skipped: requirements and design, and most of testing.

    One interview with a teacher during requirements would have revealed the need to post tasks.

  2. Compare the cost of the change: in week 1 it is one more line in the spec; in week 5 it means a new kind of user, new screens and rewriting finished code.

    Every phase completed on the wrong assumption has to be partly redone.

  3. Propose: week 1 requirements and design (interview 3 students and 2 teachers, sketch the screens); weeks 2-5 coding with tests at the end of each week; week 6 final testing and release.

    The first week makes sure the right thing is built, and weekly testing catches problems while the code is still fresh.

Answer: The mistake is skipping requirements, design and ongoing testing. Better: week 1 requirements and design with students and teachers; weeks 2-5 code and test each week; week 6 final testing and release.

Takeaway: Early phases are cheap insurance: a missing requirement costs a sentence in week 1 and a rebuild in week 5.

Where You'll See It

  • Building a house

    You plan, design, build, inspect, then maintain — skipping the inspection or design stage causes expensive problems later, just like skipping SDLC phases in software.

  • Putting on the school play

    First decide the story (requirements), plan scenes (design), rehearse (implementation), do a dress rehearsal (testing), perform (deployment), then fix issues for the next night (maintenance).

  • Updating a phone app you already shipped

    An app isn't 'done' at launch — the maintenance phase handles bug fixes and new features for years, showing the SDLC keeps cycling, not ending at deployment.

Common Mistakes

  1. The slip: The SDLC always runs strictly once in a straight line, never looping back.

    Why it's tempting: The phases are listed in order, so it looks like a one-way checklist.

    Instead: Even waterfall often revisits earlier phases when requirements change, and agile loops through the phases repeatedly in short sprints.

  2. The slip: Agile means there is no process or planning.

    Why it's tempting: Agile is described as flexible and fast, which sounds like skipping the formal steps.

    Instead: Agile has real structure — sprints, reviews, retrospectives — it just favors short cycles and feedback over one big up-front plan.

  3. The slip: You can skip requirements and design and just start coding to save time.

    Why it's tempting: Coding is the visible progress, so jumping in feels like getting ahead.

    Instead: Skipping early phases usually means building the wrong thing and discovering missing requirements late, which costs far more rework than planning would.


Mini Practice

Try these on your own. Tap Reveal when you want to check.

  1. Put these waterfall phases in order: testing, design, maintenance, requirements, deployment, implementation.

    Hint: You must know what to build before deciding how to build it.

  2. A 12-week project uses 2-week sprints. How many sprints are there, and how many working increments should the team demo?

    Hint: Each sprint ends with one working increment.

  3. Name the SDLC phase for each: (a) users report a bug after release; (b) the team interviews teachers about what a gradebook needs; (c) testers run 40 test cases.

    Hint: Is it before coding, after coding, or after release?

  4. In one project, fixing a requirements mistake costs 1 hour during design but 50 hours after deployment. If 4 such mistakes are found only after deployment, how many extra hours does that cost?

    Hint: Find the extra cost for one mistake, then multiply by 4.

  5. Project A controls sensors on a bridge, with fixed requirements set by regulators. Project B is a new student app whose features will change after feedback. Which suits waterfall, and which suits agile?

    Hint: Will the requirements change during the project?

  6. A student says: 'Our team is agile, so we don't plan, test or review. We just code whatever we feel like each day.' Correct them.

    Hint: What happens at the start and end of each sprint?

Want the full set?

50 practice questions for this concept — free to try, every one with a complete worked solution showing the why, not just the answer.

Frequently Asked Questions

Is agile better than waterfall?

Neither wins everywhere. Waterfall fits projects where requirements are fixed and mistakes are costly to undo, such as software for medical devices or aircraft, where each phase is reviewed and signed off. Agile fits products whose users do not yet know exactly what they want, like a new app, because it delivers working pieces every few weeks and adjusts. Many real teams mix the two, planning the big picture up front and building it in short cycles.

Why does fixing a mistake cost more later in the cycle?

A mistake found in the requirements costs a conversation; the same mistake found after release means changing code, retesting, shipping an update and sometimes repairing users' data. Industry studies have long reported that a defect fixed after release can cost many times more than one caught early, though the exact figures vary from project to project. That is why the cycle puts reviews and tests early, not only at the end.

Where does a student project fit in the life cycle?

It runs the same phases on a small scale. Writing down what your game must do is requirements; sketching screens and a flowchart is design; coding it and trying it on friends are implementation and testing; handing it in is deployment; and fixing what your teacher points out is maintenance. Naming the phases helps you plan your time, since students usually spend too long coding and too little testing.

What is DevOps?

DevOps is a way of working in which the people who build software and the people who run it share responsibility, and most testing and releasing is automated. Each change is tested by machines as soon as it is committed and can be deployed the same day, so the cycle turns many times a week instead of a few times a year. It carries agile ideas past coding into deployment and day-to-day operation.

Learning Path

Software Development Life Cycle

You are here

You need Design Specification first, since writing one is the main output of the requirements phase. The SDLC adds the full sequence around it (design, coding, testing, deployment and maintenance) and the models, such as waterfall, agile and spiral, that order those phases. Next come the practices that keep the later phases working: Documentation, Code Maintenance and Version Control.

See Also