Manage system life cycle phases (analysis, design, testing)

Topic 16 – System Life Cycle (SLC)

Learning objective

Students will be able to manage the six key phases of the system life cycle – analysis, design, development, testing, implementation and maintenance. They will understand the activities, artefacts and tools associated with each phase, how the phases are linked through traceability, and the project‑management, ethical, legal and societal considerations required by the Cambridge International AS & A Level IT (9626) syllabus.

Overview of the system life cycle

The SLC provides a structured, repeatable approach to creating and sustaining information systems. In the A‑Level syllabus the most common representation is the water‑fall model, which proceeds sequentially through the six phases, with formal review and sign‑off points that allow limited iteration.

Suggested diagram: Water‑fall model – Analysis → Design → Development → Testing → Implementation → Maintenance.

Phase 1 – System Analysis

Goal: Understand the problem domain and define what the new system must achieve.

  • Key activities
    1. Identify and engage stakeholders (interviews, questionnaires, observation).
    2. Gather functional and non‑functional requirements.
    3. Analyse existing processes (process mapping, flowcharts, DFDs).
    4. Carry out a feasibility study (technical, economic, legal, operational, schedule).
    5. Produce a Requirements Specification document.
  • Typical artefacts
    • Feasibility study report
    • Requirements Specification (functional & non‑functional requirements)
    • Use‑case diagrams / user stories
    • Data Flow Diagrams (DFDs) or process maps
    • Stakeholder analysis matrix
  • Tools & techniques
    • Interview schedules, questionnaires, observation checklists
    • Modelling software (Visio, Lucidchart, draw.io)
    • SWOT and PESTLE analysis
    • Requirements‑management tools (e.g., JAMA, Reqtify)
  • Project‑management activity for this phase
    • Update the risk register with analysis‑related risks (e.g., unclear requirements).
    • Record the analysis milestones in the project Gantt chart.

Phase 2 – System Design

Goal: Translate the requirements into a detailed blueprint that developers can follow – how the system will be built.

  • Key activities
    1. Define the overall system architecture (client‑server, web‑based, cloud, micro‑services).
    2. Design data structures (ER diagrams, relational schemas, data dictionaries).
    3. Design user interfaces (wireframes, mock‑ups, prototype).
    4. Specify hardware, software and network requirements.
    5. Include security design considerations (access control, encryption, audit trails).
    6. Produce a Detailed Design Specification (algorithms, pseudo‑code, interface design).
  • Typical artefacts
    • System architecture diagram
    • Entity‑Relationship (ER) diagram & data dictionary
    • Interface prototypes (low‑ and high‑fidelity)
    • Design Specification Document
    • Security design considerations (access control matrix, encryption strategy)
  • Tools & techniques
    • UML modelling tools (StarUML, Enterprise Architect, Visual Paradigm)
    • Database design tools (MySQL Workbench, pgAdmin)
    • Prototyping tools (Balsamiq, Figma, Adobe XD)
    • Architecture modelling (Archimate, C4 model)
  • Project‑management activity for this phase
    • Review the budget against design‑related hardware/software purchases.
    • Update the stakeholder register with any new design‑stage contacts.

Phase 3 – System Development

Goal: Convert the design into a working system – code the solution.

  • Key activities
    1. Set up the development environment (IDE, libraries, frameworks).
    2. Write source code following coding standards.
    3. Perform unit testing while coding.
    4. Integrate modules and manage version control.
    5. Document code (comments, API documentation).
  • Typical artefacts
    • Source code files
    • Version‑control repository (Git, SVN) with commit logs
    • Build scripts / automation files (Maven, Gradle)
    • Technical documentation (API docs, code comments)
  • Tools & techniques
    • Integrated Development Environments (Eclipse, Visual Studio, IntelliJ IDEA)
    • Version‑control systems (Git, GitHub/GitLab, Subversion)
    • Build & CI tools (Jenkins, GitHub Actions, Azure DevOps)
    • Static code analysis tools (SonarQube, ESLint)
  • Project‑management activity for this phase
    • Track development progress against the Gantt chart and adjust resources if needed.
    • Log any emerging risks (e.g., skill gaps) in the risk register.

Phase 4 – System Testing

Goal: Verify that the system meets the specified requirements and is free from defects.

  • Key activities
    1. Develop a Test Plan and detailed Test Cases linked to requirements.
    2. Execute unit tests (individual components).
    3. Carry out integration testing (combined components).
    4. Perform system testing (full system against the specification).
    5. Run acceptance testing (User Acceptance Testing – UAT).
    6. Log defects, prioritise them and manage resolution.
    7. Produce a Traceability Matrix that maps requirements to design, code and test cases.
  • Typical artefacts
    • Test Plan
    • Test Cases / Test Scripts
    • Test Report (pass/fail summary, coverage metrics)
    • Defect / Issue Log
    • Traceability Matrix (requirements ↔ design ↔ code ↔ test cases)
    • User Acceptance Test (UAT) sign‑off
  • Tools & techniques
    • Manual testing checklists and test‑case management tools (TestRail, Zephyr)
    • Automated testing frameworks (Selenium, JUnit, NUnit, Cypress)
    • Defect‑tracking systems (JIRA, Bugzilla, Redmine)
    • Performance testing tools (LoadRunner, JMeter)
  • Project‑management activity for this phase
    • Update the risk register with testing‑related risks (e.g., missed critical defects).
    • Confirm that testing milestones are met before moving to implementation.

Phase 5 – System Implementation

Goal: Deploy the system to the live environment and make it available to users.

  • Key activities
    1. Prepare a Deployment / Release Plan (including rollback procedures).
    2. Configure hardware, servers, network and security settings.
    3. Install and configure the software (scripts, containers, virtual machines).
    4. Conduct data migration and conversion.
    5. Provide user training and produce user documentation.
    6. Obtain formal sign‑off / acceptance certificate from the client or sponsor.
  • Typical artefacts
    • Deployment Plan & Release Notes
    • Installation scripts / container images (Docker, Kubernetes manifests)
    • User Manual / Help files
    • Training materials (slides, videos, hands‑on labs)
    • Sign‑off / Acceptance certificate
  • Tools & techniques
    • Configuration‑management tools (Ansible, Chef, Puppet)
    • Containerisation / orchestration (Docker, Kubernetes)
    • Database migration tools (Flyway, Liquibase)
    • Remote‑desktop or VDI for rollout, LMS for training delivery
  • Project‑management activity for this phase
    • Verify that the implementation budget has not been exceeded.
    • Record implementation risks (e.g., migration failures) and update the risk register.

Phase 6 – System Maintenance

Goal: Ensure the system continues to operate effectively, remains secure and evolves with changing user needs.

  • Key activities
    1. Monitor system performance and availability (logs, dashboards).
    2. Handle user support requests and incident management.
    3. Apply patches, updates and security fixes.
    4. Manage change requests and enhancements (change control).
    5. Plan for periodic reviews, backups and eventual de‑commissioning.
  • Typical artefacts
    • Maintenance Schedule & Service‑Level Agreement (SLA)
    • Change‑request log / Issue tracker
    • Backup and recovery procedures
    • System performance reports
    • De‑commissioning plan (if applicable)
  • Tools & techniques
    • Monitoring tools (Nagios, Zabbix, Grafana, CloudWatch)
    • Ticketing systems (ServiceNow, Freshservice)
    • Version‑control for configuration (GitOps)
    • Automated patch management (WSUS, SCCM, Ansible)
  • Project‑management activity for this phase
    • Review and update the SLA and maintenance budget annually.
    • Log any new maintenance‑related risks (e.g., vendor end‑of‑life) in the risk register.

Traceability across the whole life cycle

Traceability ensures that every requirement can be followed through design, code, test and deployment. The matrix below is a simple example of how a requirement is linked to later artefacts.

Requirement ID Design Element(s) Code Module(s) Test Case ID(s) Implementation Artefact
R‑01: User login must be authenticated Login screen UI, Authentication service LoginController.java, AuthService.py TC‑01, TC‑02 Deployment script includes AuthService configuration
R‑05: System shall generate monthly sales report Report module design, DB schema (Sales table) ReportGenerator.cs TC‑15, TC‑16 Release notes – feature “Monthly Sales Report”

Project‑management activities embedded in the SLC

  • Develop a project plan (Gantt chart) that maps each SLC phase, milestones and critical dates.
  • Maintain a risk register – identify, assess and mitigate risks (e.g., resource shortage, scope creep) and update it at the end of every phase.
  • Prepare a budget and cost‑control sheet for hardware, software licences, staff time and maintenance.
  • Create a stakeholder register and schedule regular communication (status reports, reviews, sign‑offs).
  • Use configuration management to control versions of artefacts (documents, code, deployment scripts).
  • Apply quality‑assurance processes (peer reviews, walkthroughs) at the end of each phase.

Ethical, legal and societal considerations

  • Data protection & privacy – ensure personal data collected during analysis and used in testing complies with GDPR or local data‑protection legislation; anonymise production data in test environments.
  • Security testing – include penetration testing and vulnerability scanning before deployment.
  • Intellectual‑property – respect software licences; use open‑source components in accordance with their terms.
  • Accessibility – design interfaces that meet WCAG standards to avoid digital exclusion.
  • Sustainability – consider energy consumption of servers during implementation, plan for responsible e‑waste disposal in maintenance, and evaluate the environmental impact of hardware upgrades.
  • Ethical testing – obtain informed consent from users participating in UAT; do not use production data without proper anonymisation.

Concise phase‑by‑phase matrix

Phase Key Outputs Key Tools
Analysis Feasibility study, Requirements Specification, Use‑case diagrams, Stakeholder analysis Questionnaires, Visio/draw.io, SWOT/PESTLE, JAMA
Design System architecture diagram, ER diagram & data dictionary, UI prototypes, Security design considerations UML tools (StarUML), MySQL Workbench, Figma/Balsamiq, Archimate
Development Source code, Version‑control repository, Build scripts, API documentation IDE (IntelliJ/Eclipse), Git, Jenkins, SonarQube
Testing Test Plan, Test Cases, Traceability Matrix, Defect log, UAT sign‑off TestRail, Selenium/JUnit, JIRA, JMeter
Implementation Deployment plan, Installation scripts, User manual, Training material, Acceptance certificate Ansible/Chef, Docker/Kubernetes, Flyway, LMS
Maintenance Maintenance schedule & SLA, Change‑request log, Backup & recovery procedures, De‑commissioning plan Grafana/Nagios, ServiceNow, GitOps, Ansible (patches)

Managing the phases in practice

  • Maintain **clear, version‑controlled documentation** at each stage to support traceability.
  • Schedule **formal review and sign‑off points** (after analysis, design, testing, etc.) with relevant stakeholders.
  • Continuously **assess and update the risk register** as new issues emerge.
  • Allow **controlled iteration** – if a defect or new requirement is discovered, feed it back to the appropriate earlier phase with a documented change request.
  • Use the **concise matrix** above as a quick reference for exam revision and for checking that all required artefacts are produced.

Create an account or Login to take a Quiz

42 views
0 improvement suggestions

Log in to suggest improvements to this note.