# Software lifecycle

> CIE A-Level Computer Science · 9618
> Source: https://www.owlsprep.com/study/cie-9618-u12-software-lifecycle/

This module covers core stages of software development lifecycles, common models used in industry and exams, and how to select the right model for specific project requirements, aligned with CIE 9618 learning outcomes.

**Prerequisites:** [Basic understanding of software development concepts](https://www.owlsprep.com/study/cie-9618-u11-introduction-to-software/)

## Learning objectives

- Describe the core stages common to all software lifecycles
- Compare and contrast key software lifecycle models
- Select and justify the appropriate model for a given project scenario
- Identify advantages and disadvantages of common models

## Core Stages of All Software Lifecycles

All software lifecycle models are structured frameworks for building and maintaining software. Regardless of the specific model used, they all share core high-level stages that map the process from initial idea to final retirement.

**Software Lifecycle** — A structured framework that describes all stages involved in developing, deploying, and maintaining a software product from initial conception to final retirement.

| Stage | Key Activities |
| --- | --- |
| Feasibility | Assess technical, financial, operational project viability |
| Requirements analysis | Gather and document required software functionality |
| Design | Plan architecture, data structures and user interfaces |
| Implementation | Write code and build the working software |
| Testing | Verify requirements are met and fix defects |
| Deployment | Release software to end users |
| Maintenance & Retirement | Update/fix software, retire when obsolete |

**Worked example:** List the core stages of the software lifecycle that occur after a feasibility study is approved, and before deployment.

1. 1. After feasibility approval, the first stage is requirements analysis. The team meets with stakeholders to gather and document all functional and non-functional requirements, which are then signed off.
2. 2. Next, the design stage produces architecture diagrams, database schemas, and interface mockups that meet the documented requirements.
3. 3. Implementation follows, where developers write code based on the design specifications to build the software.
4. 4. Finally, testing verifies that the software works as required and fixes all identified defects, before progressing to deployment.

## The Waterfall Model

The Waterfall model is the original traditional sequential lifecycle model, where each stage is completed fully in order, and you cannot return to a previous stage once it is finished.

**Waterfall Model** — A linear, sequential lifecycle model where each stage is completed fully before progressing to the next, with no built-in backtracking or iteration.

*Example:* Used for small, low-risk projects with completely fixed, agreed requirements where changes are not expected.

**Worked example:** A small local business needs a simple static website, with all requirements fixed and agreed in writing. Explain why the Waterfall model is appropriate for this project.

1. 1. Waterfall is ideal for small projects with stable, fixed requirements, which matches the description of this project.
2. 2. Waterfall has very low administrative overhead compared to iterative models, making it efficient and cost-effective for a low-budget small project.
3. 3. No changes are expected after requirements are agreed, so there is no need for the flexibility of an iterative model. The project can be completed quickly in a single sequential pass.

> **Exam tip:** In CIE exams, always link the properties of the model to the specific scenario when justifying your choice, to earn full marks.

## Iterative, Incremental and Agile Models

Iterative models break development into repeated cycles, refining the product each cycle to incorporate feedback. Incremental models deliver working software in small, functional chunks, adding new features each cycle. Modern Agile methodologies (like Scrum) combine both approaches.

**Agile Software Development** — A flexible, iterative approach to software development that prioritizes rapid delivery of working software, responding to changing requirements, and continuous customer feedback.

**Worked example:** A startup is building a new consumer mobile app, and needs to release new features monthly to respond to user feedback and changing market trends. Justify why Agile is the right model here.

1. 1. Agile uses short 2-4 week development cycles (sprints) that allow the team to deliver new working features every month, matching the startup's requirement for regular releases.
2. 2. Agile is designed to accommodate changing requirements, so the team can easily incorporate user feedback and market changes into future sprints.
3. 3. Early delivery of working software allows the startup to test the product with real users early, reducing the risk of building a product that does not meet market needs.

## Spiral and RAD Models

Two other common models tested in CIE 9618 are the Spiral model (for high-risk projects) and Rapid Application Development (RAD, for fast, user-focused development). The Spiral model combines Waterfall structure with iterative development and a strong focus on risk management.

**Spiral Model** — A risk-driven iterative lifecycle model that requires a formal risk assessment and mitigation step before each new development cycle.

**Worked example:** A large aerospace company is developing new safety-critical flight control software for commercial aircraft. Which lifecycle model is most suitable, and why?

1. 1. The Spiral model is the most suitable choice for this project.
2. 2. This is a large, high-risk project: any software defect could have catastrophic consequences, so rigorous risk analysis is required before every development stage.
3. 3. The Spiral model requires explicit risk identification and mitigation at the start of each cycle, which matches the safety requirements of this project.
4. 4. Repeated prototyping and testing in each spiral cycle also reduces the chance of critical defects being missed, which is essential for a safety-critical system.

## Common pitfalls

- **Wrong:** Claiming Agile does not include all core software lifecycle stages
  - Why it fails: All core stages are still completed in Agile, just repeated incrementally across sprints instead of done once at the start
  - Correct: State that core stages are repeated for each increment, rather than omitted entirely
- **Wrong:** Claiming Waterfall is never used in modern development
  - Why it fails: Waterfall is still appropriate for small projects with completely fixed requirements and low overhead needs
  - Correct: Justify Waterfall for small, fixed-requirement scenarios where iteration is unnecessary
- **Wrong:** Confusing incremental and iterative development
  - Why it fails: The terms describe different concepts, even though modern models combine both
  - Correct: Remember: incremental = adding new functionality in chunks, iterative = refining the product through repeated cycles
- **Wrong:** Selecting Agile for all large projects
  - Why it fails: Agile lacks the rigorous documentation and formal risk analysis required for regulated safety-critical projects
  - Correct: Select Spiral or Waterfall for safety-critical, regulated projects with fixed requirements
- **Wrong:** Forgetting to include maintenance as a core lifecycle stage
  - Why it fails: Most software spends most of its lifetime in the maintenance stage after deployment
  - Correct: Always include maintenance (and eventual retirement) when listing lifecycle stages in exams

## Cheatsheet

| Model | Best For | Key Advantage | Key Disadvantage |
| --- | --- | --- | --- |
| Waterfall | Small, fixed requirements, low risk | Simple, low overhead, clear documentation | Cannot handle changes, late testing |
| Agile | Dynamic requirements, consumer products | Fast delivery, adapts to change | Higher overhead, less formal documentation |
| Spiral | Large, high-risk, safety-critical projects | Explicit risk management | Time-consuming and expensive |
| RAD | Fast development, user-focused projects | Quick delivery, early user feedback | Poor focus on non-functional requirements |

## What's next

Understanding software lifecycle models is a foundational topic for CIE 9618 Paper 1, and is assessed almost every year in both multiple choice and structured response questions. You will often be asked to select and justify a model for a given scenario, so practicing matching model properties to scenario characteristics is key to earning full marks. This knowledge underpins all subsequent software development topics, where you will explore individual lifecycle stages in more detail for exam assessment.

- [Requirement Analysis](https://www.owlsprep.com/study/cie-9618-u12-requirement-analysis/)
- [Software Design Methods](https://www.owlsprep.com/study/cie-9618-u12-software-design-methods/)
- [Testing](https://www.owlsprep.com/study/cie-9618-u12-testing/)

---

From [OwlsPrep](https://www.owlsprep.com) — free study guides for A-Level, IB, AP and IGCSE, written against the official syllabus. Canonical page: https://www.owlsprep.com/study/cie-9618-u12-software-lifecycle/