1.1.

Introduction

The System Development Life Cycle (SDLC) is a systematic and structured process used to
plan, create, test, deploy, and maintain an information system or software application. It
provides a clear framework for guiding software development from the initial idea to its final
release and continued support. The SDLC ensures that the development process is efficient,
cost-effective, and meets the functional and technical requirements of end users and
stakeholders. It typically includes several well-defined phases such as planning, analysis,
design, development, testing, deployment, and maintenance. Each phase has specific
deliverables and activities that help manage complexity, reduce risk, and improve the overall
quality of the system. The SDLC supports better project management, improved
communication among team members, and helps ensure that projects are delivered on time and
within budget (Pressman & Maxim, 2014).

1.2. The Following are the phase of the Software Development Life Cycle (SDLC)

1.2.1. Planning Phase

The planning phase lays the critical groundwork for the entire software development lifecycle.
It begins with identifying the business need or problem the system aims to solve. Project goals
are clearly defined, including what success looks like and how it will be measured. This phase
involves scoping out the work—determining the system’s boundaries, features, and the
resources (time, money, personnel) required to complete it. A feasibility study is conducted to
assess whether the project is technically feasible, cost-effective, and operationally viable.
(Sommerville 2016).

1.2.2. Analysis Phase

This phase focuses on gathering in-depth requirements from the end-users and stakeholders to
ensure that the future system will meet their actual needs. Requirements gathering techniques
include interviews, questionnaires, observations, document analysis, and focus group
workshops. These inputs are then used to create a Software Requirements Specification (SRS)
document, which becomes the foundation for the design phase. The SRS clearly outlines
functional requirements (what the system should do, e.g., generate reports) and non-functional
requirements (how the system performs under constraints, e.g., speed, security, reliability).
(Dennis, Wixom, and Roth 2015).

1.2.3. Design Phase

During the design phase, the system’s requirements are translated into a logical and physical
structure. This includes both high-level design (overall system architecture, modules, database
1
schema, and data flow) and detailed design (specific algorithms, input/output screens, reports,
and user interface design). Tools such as UML diagrams, Entity-Relationship (ER) diagrams,
and Data Flow Diagrams (DFDs) are used to visually represent components and their
interactions. Security protocols, system interfaces, and third-party integrations are also detailed.
(Shelly and Rosenblatt 2011)

1.2.4. Development (Implementation) Phase

The development phase involves turning design specifications into actual code. Developers
select appropriate programming languages, frameworks, and development tools suited to the
project’s requirements. The coding is often carried out in modules or units, which are built and
tested individually. Following best practices like coding standards, documentation, and version
control is essential to ensure quality and collaboration. (Pressman and Maxim 2014)

1.2.5. Testing Phase

After the system is built, it undergoes rigorous testing to ensure it performs as expected under
different scenarios. The process begins with integration testing, which checks if individual
modules or services work together seamlessly. Next, system testing validates the entire
application’s functionality against the requirements outlined in the SRS. (Sommerville 2016).

1.2.6. Deployment Phase

Once the system has passed testing, it moves to the deployment phase, where it is released into
the production environment. This process may involve a full-scale launch or a pilot deployment
in a limited area or user group to ensure stability before a broader release. Activities include
setting up the hardware environment, configuring databases, installing necessary software
packages, and migrating data from old systems. (Shelly and Rosenblatt 2011).

1.2.7. Maintenance Phase

This phase begins after deployment and continues throughout the software’s life. It includes
corrective maintenance (fixing bugs or errors discovered post-deployment), adaptive
maintenance (updating the software to remain compatible with new environments or
regulations), and perfective maintenance (enhancing features based on user feedback or
evolving needs). (Pressman and Maxim 2014).

1.3. The following are the models of SDLC.

The Waterfall Model is one of the earliest and most traditional SDLC models. It follows a strict
linear sequence, meaning that each phase—requirements, design, implementation, testing,
deployment, and maintenance—must be completed before the next phase begins. This model
2
works best when requirements are well-understood, fixed, and unlikely to change, such as in
government or regulatory projects. (Sommerville 2016)

1.3.2. V-Model (Validation and Verification Model)

The V-Model is an extension of the Waterfall Model that introduces a strong emphasis on
validation and verification at each development phase. Each development activity (e.g.,
requirement analysis, design, coding) is paired with a corresponding testing activity (e.g.,
acceptance testing, integration testing, unit testing), forming a V-shaped process.. (Pressman
and Maxim 2014)

1.3.3. Incremental Model

The Incremental Model divides the development process into smaller, manageable increments
or components. Each increment goes through the full SDLC cycle—requirements, design,
development, and testing—culminating in a partial product delivery. These increments are
developed and delivered in succession, allowing early user interaction and feedback. (Dennis
et al. 2015)

1.3.4. Spiral Model

The Spiral Model integrates aspects of iterative development with a strong emphasis on risk
management. Each iteration, or “spiral,” includes four main phases: planning, risk assessment,
engineering (design and development), and evaluation. The project cycles through these spirals
repeatedly, with each loop adding progressively refined system functionality. This approach is
especially suitable for large-scale, mission-critical, and high-risk projects, such as aerospace or
defense systems. (Sommerville 2016)

1.3.5. Agile Model

The Agile Model promotes adaptive planning, rapid delivery, and continuous stakeholder
collaboration. Unlike traditional models, Agile breaks down development into small, time-
boxed cycles called sprints, typically lasting 1–4 weeks. Each sprint results in a working product
increment that is reviewed by the client, allowing for frequent feedback and swift course
correction. (Beck et al, 2001)

1.3.6. DevOps Model

The DevOps Model aims to bridge the gap between software development (Dev) and IT
operations (Ops) by promoting continuous integration, continuous delivery (CI/CD),
automation, and collaborative culture. It focuses on shortening the SDLC while delivering high-
quality software reliably. DevOps involves the use of automated pipelines for building, testing,
deploying, and monitoring software. (Bass, Weber, and Zhu (2015)
3
 REFERENCE
Beck, K. et al. (2001). Manifesto for Agile Software Development. Agile Alliance.
Bass, L., Weber, I., & Zhu, L. (2015). DevOps: A Software Architect's Perspective. Addison-
Wesley.
Dennis, A., Wixom, B. H., & Roth, R. M. (2015). Systems Analysis and Design. Wiley.
Pressman, R. S., & Maxim, B. R. (2014). Software Engineering: A Practitioner’s Approach (8th
ed.). McGraw-Hill.
Shelly, G. B., & Rosenblatt, H. J. (2011). Systems Analysis and Design. Cengage Learning.
Sommerville, I. (2016). Software Engineering (10th ed.). Pearson.