Lesson Notes By Weeks and Term v3 - Senior Secondary 2
Systems Development Cycle
Download the Lessonotes Mobile Nigeria 2025 app for faster lesson access on Android and iPhone.
Systems Development Cycle
Download the Lessonotes Mobile Nigeria 2025 app for faster lesson access on Android and iPhone.
Subject: Computer & IT
Class: Senior Secondary 2
Term: 3rd Term
Week: 2
Theme: Developing Problem-Solving Skills
This page supports the lesson note with a companion video and a short classroom-ready summary.
For class groups and homework, share this lesson page so learners also get the summary, objectives, and full lesson context.
Define systemdevelopment cycle Describe Systemdevelopment cycle. Draw a systemdevelopment cycle List stages in System Development Cycle Describe briefly,each of the stagesinvolved.
The Systems Development Cycle (SDLC) is a conceptual model used in project management that describes the stages involved in an information system development project, from initial feasibility study to maintenance of the completed application. It provides a structured methodology for building, maintaining, and enhancing information systems. 2.
1. Definition of Key Terms: System: A group of interacting or interrelated components that form a unified whole. In the context of IT, an information system is a set of interconnected components working together to collect, process, store, and disseminate information to support decision-making, coordination, control, analysis, and visualization in an organization. Examples include a school management system, a banking system, or a hospital information system.
Development: The process of creating something new or improving an existing one. In computing, it refers to the design, programming, and implementation of software or hardware solutions.
Cycle: A series of events that are regularly repeated in the same order. The term "cycle" implies that system development is not a one-off event but an iterative process, often requiring re-evaluation and adaptation. 2.
2. Definition of Systems Development Cycle (SDLC): The Systems Development Cycle (SDLC) is a logical sequence of activities that takes a system from its inception to its final operational use. It is a structured process that enables organizations to design, implement, and maintain high-quality information systems efficiently and effectively. Different organizations might adopt slightly varied models (e.g., Waterfall, Agile, Spiral), but they generally follow the core stages outlined below. 2.
3. Stages in the Systems Development Cycle: A typical SDLC consists of the following sequential stages: Stage 1: Preliminary Investigation / Feasibility Study / Planning Objective: To determine the viability of a proposed system and define its scope.
Description: This initial stage involves identifying the problem or opportunity, establishing the project objectives, and conducting a high-level assessment of the system's feasibility.
Problem Identification: What issue is the current system facing, or what new opportunity can be exploited? (e.g., "Our school's manual student registration is too slow and error-prone.")
Objective Setting: What are the specific goals the new system aims to achieve? (e.g., "Automate student registration to reduce processing time by 50% and eliminate manual errors.")
Feasibility Analysis: Evaluating the project's practicality across several dimensions: Technical Feasibility: Is the required technology available and can it be implemented? (e.g., Does the school have the necessary computers and network infrastructure?)
Economic Feasibility: Is the project cost-effective? Do the benefits outweigh the costs? (e.g., Can the school afford the software, hardware, and training? Will it save money in the long run?)
Operational Feasibility: Will the proposed system work in the organization's environment? Will users accept and adapt to it? (e.g., Are teachers and administrators willing to use a new system?)
Schedule Feasibility: Can the project be completed within a reasonable timeframe? (e.g., Can the system be ready before the next academic session?)
Legal/Ethical Feasibility: Does the system comply with laws and regulations? (e.g., Does it protect student data privacy according to Nigerian data protection laws?)
Outcome: A feasibility report recommending whether to proceed, abandon, or modify the project. If approved, a project plan and schedule are developed.
Stage 2: Systems Analysis Objective: To thoroughly understand the requirements of the new system and what it needs to achieve.
Description: If the feasibility study indicates the project is viable, the analysis stage begins. Analysts gather detailed information from users and stakeholders about their needs, how the current system works, and what challenges they face.
Requirements Gathering: Techniques include interviews with users (e.g., school principal, teachers, bursar), questionnaires, observation of existing processes (e.g., how students currently register), and reviewing existing documents (e.g., registration forms, attendance registers).
Analysis of Current System: Identifying strengths and weaknesses of the existing system.
Definition of User Needs: Specifying what the new system must do (functional requirements) and how well it must perform (non-functional requirements like speed, security).
Modelling: Using tools like Data Flow Diagrams (DFDs) to represent how data moves through the system, and Entity-Relationship Diagrams (ERDs) to model the database structure (these are advanced concepts, can be mentioned briefly). * Outcome: observation of existing processes (e.g., how students currently register), and reviewing existing documents (e.g., registration forms, attendance registers).
Analysis of Current System: Identifying strengths and weaknesses of the existing system.
Definition of User Needs: Specifying what the new system must do (functional requirements) and how well it must perform (non-functional requirements like speed, security).
Modelling: Using tools like Data Flow Diagrams (DFDs) to represent how data moves through the system, and Entity-Relationship Diagrams (ERDs) to model the database structure (these are advanced concepts, can be mentioned briefly).
Outcome: A detailed System Requirements Specification (SRS) document, outlining exactly what the system should do.
Stage 3: Systems Design Objective: To create a detailed blueprint of the new system, specifying how it will meet the requirements identified during analysis.
Description: This stage translates the "what" (requirements from analysis) into "how" (technical specifications). It involves designing the system's architecture, components, interfaces, and data structures.
Logical Design: Defines the system's abstract structure and processes, independent of any specific hardware or software. It focuses on the system's functions, inputs, outputs, and data flows. (e.g., How student data will be logically organized, what reports will be generated).
Physical Design: Translates the logical design into concrete technical specifications.
This includes: User Interface Design: How users will interact with the system (screens, menus, buttons).
Database Design: Structure of the database, tables, relationships (e.g., separate tables for students, courses, grades).
Input/Output Design: How data will be entered and how results will be presented.
Network Design: If the system is networked.
Security Design: Measures to protect data and access.
Hardware and Software Specifications: What technology is needed.
Outcome: A comprehensive System Design Document (SDD) detailing the system's architecture and technical specifications, ready for development.
Stage 4: Systems Development / Implementation (Coding & Testing)
Objective: To build the system based on the design specifications and ensure it functions correctly.
Description: This is where the actual coding and construction of the system take place.
Programming/Coding: Developers write the actual software code based on the design document, using appropriate programming languages (e.g., Python, Java, PHP for web systems).
Database Creation: The database specified in the design phase is created and populated (if necessary).
Hardware & Software Installation: Necessary hardware (servers, workstations) and software (operating systems, database management systems) are procured and set up.
Testing: A critical part of this stage to identify and fix errors.
Unit Testing: Individual modules or components are tested.
Integration Testing: Modules are combined and tested to ensure they work together.
System Testing: The complete system is tested as a whole to verify it meets all requirements.
User Acceptance Testing (UAT): End-users (e.g., teachers, administrators) test the system to ensure it meets their needs and is ready for deployment.
Documentation: Creation of user manuals (how to use the system) and technical manuals (how the system works, for future developers/maintenance staff).
Outcome: A fully coded, tested, and documented system ready for deployment.
Stage 5: Systems Implementation / Deployment (Installation & Training)
Objective: To install the new system into the operational environment and prepare users for its adoption.
Description: This stage focuses on bringing the new system into actual use.
Installation: The new system is installed on the organization's hardware and network.
Data Conversion/Migration: Existing data from the old system (if any) is converted and transferred to the new system. (e.g., transferring old student records to the new digital database).
User Training: End-users are trained on how to operate and interact with the new system. (e.g., training teachers on how to enter grades and generate reports).
Changeover Strategies: How to switch from the old system to the new one: Direct Changeover: Old system is immediately replaced by the new one (risky).
Parallel Changeover: Both old and new systems run simultaneously for a period (safest but costly).
Phased Changeover: New system is introduced module by module. * Pilot Changeover: New system is first implemented in a small part of the organization (e.g., one department or branch) before full rollout. interact with the new system. (e.g., training teachers on how to enter grades and generate reports).
Changeover Strategies: How to switch from the old system to the new one: Direct Changeover: Old system is immediately replaced by the new one (risky).
Parallel Changeover: Both old and new systems run simultaneously for a period (safest but costly).
Phased Changeover: New system is introduced module by module.
Pilot Changeover: New system is first implemented in a small part of the organization (e.g., one department or branch) before full rollout.
Outcome: The new system is live and operational, and users are trained.
Stage 6: Systems Maintenance Objective: To ensure the system continues to function effectively, address issues, and adapt to changing needs over its lifespan.
Description: Once the system is live, it requires ongoing maintenance to ensure its continued performance and relevance.
Post-Implementation Review: An assessment shortly after deployment to evaluate the system's success and identify areas for improvement.
Corrective Maintenance: Fixing bugs or errors discovered after implementation. (e.g., A report generating incorrect totals).
Adaptive Maintenance: Modifying the system to adapt to changes in the operating environment (e.g., new government regulations, updated hardware, operating system upgrades).
Perfective Maintenance: Enhancing the system by adding new features, improving performance, or making it more user-friendly based on user feedback. (e.g., Adding an SMS notification feature to the school system).
Preventive Maintenance: Proactive activities to prevent future problems (e.g., regular database backups, security updates).
Outcome: A stable, functional, and evolving system that meets ongoing organizational needs. This stage often leads back to the planning stage for new enhancements or a completely new system, thus completing the "cycle." 2.
4. Drawing a Systems Development Cycle: The SDLC can be represented as a circular flow or a linear progression with feedback loops. A simple diagram emphasizes the sequential nature and the return to maintenance leading to potential new cycles. ``` +-------------------------+ |
1. Planning / | | Feasibility Study | +-----------+-------------+ | v +-----------+-------------+ |
2. Systems Analysis | +-----------+-------------+ | v +-----------+-------------+ |
3. Systems Design | +-----------+-------------+ | v +-----------+-------------+ |
4. System Development | | (Coding & Testing) | +-----------+-------------+ | v +-----------+-------------+ |
5. System | | Implementation | | (Deployment & Training)| +-----------+-------------+ | v +-----------+-------------+ |
6. System Maintenance | +-----------+-------------+ ^ | +---------------------+ (Feedback/New Requirements) ``` (Alternative representation can be a circular diagram where each stage leads to the next, and Maintenance loops back to Planning).
Teacher Activities: Introduction: Begin by posing questions about familiar digital systems (e.g., "How do you think apps like WhatsApp or bank mobile apps are created and improved?").
Definition & Overview: Define 'System', 'Development', 'Cycle', and combine them to define SDL
C. Explain its importance in structuring IT projects.
Stage-by-Stage Explanation: Introduce each stage of the SDLC sequentially. For each stage, provide a clear explanation of its purpose, key activities, and expected outputs. Use relatable Nigerian examples for each stage. For instance, for 'Planning', discuss the initial idea for a new online registration portal for WAEC or JAMB. For 'Analysis', talk about gathering requirements from students, parents, and examination bodies. Emphasize the logical flow from one stage to the next.
Diagrammatic Representation: Draw a simple SDLC diagram on the board, explaining the flow and showing how maintenance can lead back to planning.
Interactive Discussion: Facilitate a class discussion by presenting a hypothetical scenario (e.g., "A new e-commerce website for locally made Nigerian goods is to be developed. What would happen at each stage?"). Encourage students to contribute ideas for each stage.
Q&A Session: Address student questions to clarify any misconceptions.
Group Activity Setup: Divide students into small groups and assign each group a local system development scenario (e.g., "Developing an app for farmers to sell their produce directly," "Creating a digital library system for the school"). Instruct them to briefly outline activities for each SDLC stage for their scenario.
Wrap-up: Summarize the key takeaways, reinforcing the sequential nature and importance of each SDLC stage.
Student Activities: Active Listening & Note-taking: Pay attention to explanations and take comprehensive notes on definitions, stages, and examples.
Participation in Discussions: Contribute ideas and answers during class discussions, especially when discussing real-world Nigerian examples.
Diagram Drawing: Replicate the SDLC diagram in their notebooks as explained by the teacher.
Group Scenario Analysis: In assigned groups, students will: Read their given system development scenario. Discuss and identify the types of activities that would occur in each of the six SDLC stages for their specific scenario. Appoint a group representative to present their findings to the class.
Questioning: Ask questions to clarify understanding of concepts or stages.
JAMB/WAEC Online Registration and Result Checking Systems: The development of platforms like the JAMB UTME registration portal or the WAEC e-Result checker follows the SDL
C. Planning: Identifying the need for online registration/result checking to improve efficiency and reduce physical queues.
Analysis: Gathering requirements from students, parents, schools, and examination bodies on what information to collect, how results should be displayed, and security measures.
Design: Architecting the database to store millions of student records, designing user-friendly interfaces, and ensuring robust security features.
Development: Coding the portal, integrating payment gateways, and rigorous testing for scalability and security.
Implementation: Launching the portal, user support, and public awareness campaigns.
Maintenance: Regularly updating security patches, improving server capacity during peak periods, and adding new features like direct messaging. Mobile Banking Applications by Nigerian Commercial Banks: Every major Nigerian bank's mobile app (e.g., GTBank, Access Bank, Zenith Bank) has gone through an SDL
C. Planning: Identifying the market need for convenient mobile banking.
Analysis: Understanding user preferences for transactions, security needs, and regulatory compliance (CBN guidelines).
Design: Creating intuitive user interfaces, designing secure transaction flows, and integrating with core banking systems.
Development: Coding the app for Android and iOS, implementing encryption, and extensive testing (unit, integration, penetration testing).
Implementation: Releasing the app on app stores, marketing, and user training/support.
Maintenance: Regular updates for bug fixes, new feature rollouts (e.g., new payment options, biometric login), and adapting to new smartphone OS versions. Community Water Management System (Hypothetical Local Initiative): A community in Nigeria wants a digital system to manage water distribution and billing for communal boreholes.
Planning: Community leaders identify issues with manual record-keeping and revenue collection for water.
Analysis: Interviewing water vendors, community members, and accountants to understand usage patterns, payment methods, and desired reports.
Design: Designing a simple system for recording water dispensed, generating bills, and tracking payments, perhaps on a tablet or a basic computer.
Development: Building the software application, potentially using open-source tools or engaging a local developer.
Implementation: Installing the system at borehole points, migrating existing customer data, and training water vendors on its use.
Maintenance: Fixing issues, adding features like SMS reminders for payments, or adapting to changes in water tariff.