Software Development Life Cycle Overview
Software Development Life Cycle Overview
1
A few basic concepts of lifecycle models
• Software Development Life Cycle (SDLC) is a structured process that is used to design,
develop, and test high-quality software. SDLC, or software development life cycle, is a
methodology that defines the entire procedure of software development step-by-step. The goal
of the SDLC life cycle model is to deliver high-quality, maintainable software that meets the
user's requirements.
• SDLC in software engineering models outlines the plan for each stage so that each stage of
the software development model can perform its task efficiently to deliver the software at a
low cost within a given time frame that meets user's requirements.
• SDLC is a process followed for software building within a software organization. SDLC consists
of a precise plan that describes how to develop, maintain, replace, and enhance specific software.
The life cycle defines a method for improving the quality of software and the all-around
development process.
• Planning is a crucial step in everything. In this same stage, requirement analysis is also performed
by the developers of the organization. This is attained from customer inputs, and sales
department/market surveys.
• The information from this analysis forms the building blocks of a basic project. The quality of the
project is a result of planning. Thus, in this stage, the basic project is designed with all the
available information.
• In this stage, all the requirements for the target software are specified. These requirements get
approval from customers, market analysts, and stakeholders. This is fulfilled by utilizing SRS
(Software Requirement Specification). This is a sort of document that specifies all those things
that need to be defined and created during the entire project cycle. 2025 MANIPAL ACADEMY OF HIGHER EDUCATION
5
Stage 3: Designing Architecture
• SRS is a reference for software designers to come up with the best architecture for the software.
Hence, with the requirements defined in SRS, multiple designs for the product architecture are
present in the Design Document Specification (DDS).
• This DDS is assessed by market analysts and stakeholders. After evaluating all the possible factors,
the most practical and logical design is chosen for development.
• At this stage, the fundamental development of the product starts. For this, developers use a specific
programming code as per the design in the DDS. Hence, it is important for the coders to follow the
protocols set by the association. Conventional programming tools like compilers, interpreters,
debuggers, etc. are also put into use at this stage. Some popular languages like C/C++, Python, Java,
etc. are put into use as per the software regulations.
2025 MANIPAL ACADEMY OF HIGHER EDUCATION
6
Stage 5: Product Testing and Integration
• After the development of the product, testing of the software is necessary to ensure its smooth
execution. Although, minimal testing is conducted at every stage of SDLC. Therefore, at this
stage, all the probable flaws are tracked, fixed, and retested. This ensures that the product
confronts the quality requirements of SRS.
• After detailed testing, the conclusive product is released in phases as per the organization’s
strategy. Then it is tested in a real industrial environment. It is important to ensure its smooth
performance.
• This classical waterfall model is simple and idealistic. It is important because most other Types of
Software Development Life Cycle Models are a derivative of this.
• The waterfall model is a Software Development Model used in the context of large, complex
projects, typically in the field of information technology. It is characterized by a structured,
sequential approach to Project Management and Software Development.
2025 MANIPAL ACADEMY OF HIGHER EDUCATION
8
Phases of Waterfall Model
• System Design − The requirement specifications from first phase are studied in this phase and the
system design is prepared. This system design helps in specifying hardware and system
requirements and helps in defining the overall system architecture.
• Implementation − With inputs from the system design, the system is first developed in small
programs called units, which are integrated in the next phase. Each unit is developed and tested for
its functionality, which is referred to as Unit Testing.
• Integration and Testing − All the units developed in the implementation phase are integrated into
a system after testing of each unit. Post integration the entire system is tested for any faults and
failures.
• Maintenance − There are some issues which come up in the client environment. To fix those
issues, patches are released. Also to enhance the product some better versions are released.
Maintenance is done to deliver these changes in the customer environment.
• Phases are processed and completed one at a time. • Not a good model for complex and object-
• Works well for smaller projects where oriented projects.
requirements are very well understood.
• Poor model for long and ongoing projects.
• Clearly defined stages.
• It is difficult to measure progress within stages.
• Well understood milestones.
• Model provides feedback paths from every phase to its preceding phases
• When errors are detected at some later phase, these feedback paths allow for correcting errors
committed by programmers during some phase.
• The feedback paths allow the phase to be reworked in which errors are committed, and these
changes are reflected in the later phases.
• Requirements Gathering: This is the first stage where the business owners and developers meet
to discuss the goals and requirements of the website.
• Design: In this stage, the developers create a preliminary design of the website based on the
requirements gathered in stage 1.
• Implementation: In this stage, the developers begin to build the website based on the design
created in stage 2.
• Testing: Once the website has been built, it is tested to ensure that it meets the requirements and
functions properly.
• Deployment: The website is then deployed and made live to the public.
• Review and Improvement: After the website has been live for a while, the business owners and
developers review its performance and make any necessary improvements. 2025 MANIPAL ACADEMY OF HIGHER EDUCATION
15
• Iterative model - Advantages • Iterative model - disadvantages
• The V-Model is an extension of the waterfall model and is based on the association of a testing
phase for each corresponding development stage. This means that for every single phase in the
development cycle, there is a directly associated testing phase. This is a highly-disciplined model
and the next phase starts only after completion of the previous phase.
• This is the first phase in the development cycle where the product requirements are understood from
the customers perspective. This phase involves detailed communication with the customer to
understand his expectations and exact requirement. This is a very important activity and needs to be
managed well, as most of the customers are not sure about what exactly they need. The acceptance
test design planning is done at this stage as business requirements can be used as an input for
acceptance testing.
System Design
• Once you have the clear and product requirements, it is time to design the complete system. The
system design will have the understanding and detailing the complete hardware and communication
setup for the product under development. The system test plan is developed based on the system
design. Doing this at an earlier stage leaves more time for the actual test execution later.
• Architectural specifications are understood and designed in this phase. Usually more than one
technical approach is proposed and based on the technical and financial feasibility the final
decision is taken. The system design is broken down further into modules taking up different
functionality. This is also referred to as High Level Design (HLD).
Module Design
• In this phase, the detailed internal design for all the system modules is specified, referred to
as Low Level Design (LLD). It is important that the design is compatible with the other modules
in the system architecture and the other external systems. The unit tests are an essential part of any
development process and helps eliminate the maximum faults and errors at a very early stage.
These unit tests can be designed at this stage based on the internal module designs.
• The actual coding of the system modules designed in the design phase is taken up in the Coding
phase. The best suitable programming language is decided based on the system and architectural
requirements.
• The coding is performed based on the coding guidelines and standards. The code goes through
numerous code reviews and is optimized for best performance before the final build is checked
into the repository.
are completed one at a time. • Not a good model for complex and object-
requirements are very well understood. • Poor model for long and ongoing projects.
• Simple and easy to understand and use. • Not suitable for the projects where requirements
are at a moderate to high risk of changing.
• Easy to manage due to the rigidity of the
model. Each phase has specific deliverables • Once an application is in the testing stage, it is
• The Incremental Process Model is a method of software development where the system is built
step by step. Instead of delivering the whole system at once, it is developed and delivered in small
parts called increments. Each increment builds upon the previous one by adding new functionality,
until the complete system is finished.
• The first step in the Incremental Model is understanding what the software needs to do. The team
gathers the requirements from the product experts and clearly defines the system’s functional
needs. This phase is important because it sets the foundation for everything else in the
development process.
• Next, the team focuses on designing how the software will function and starts developing it. They
work on adding new features and making sure the system works as expected. The design and
development steps go hand-in-hand to build the functionality of the software.
• Once a feature is developed, it goes through testing. The testing phase checks how the software
performs, including both new and existing features. The team uses different testing methods to
make sure everything is working correctly.
• Implementation
• This phase involves writing the final code based on the design and development steps. After
testing the functionality, the team verify that everything is working as planned. By the end of this
phase, the product is gradually improved and updated until it becomes the final working version.
• The Spiral Model is a Software Development Life Cycle (SDLC) model that provides a
systematic and iterative approach to software development. In its diagrammatic representation,
looks like a spiral with many loops. The exact number of loops of the spiral is unknown and can
vary from project to project. Each loop of the spiral is called a phase of the software development
process.
• The Spiral Model is a risk-driven model, meaning that the focus is on managing risk through
multiple iterations of the software development process.
1. Objectives Defined
• In first phase of the spiral model will clarify what the project aims to achieve, including functional
and non-functional requirements.
• Requirements are gathered from the customers and the objectives are identified, elaborated, and
analyzed at the start of every phase. Then alternative solutions possible for the phase are proposed
in this quadrant.
• In the risk analysis phase, the risks associated with the project are identified and evaluated.
• During the second quadrant, all the possible solutions are evaluated to select the best possible
solution. Then the risks associated with that solution are identified and the risks are resolved using
the best possible strategy. At the end of this quadrant, the Prototype is built for the best possible
2025 MANIPAL ACADEMY OF HIGHER EDUCATION
30
solution.
3. Develop the next version of the Product
• During the third quadrant, the identified features are developed and verified through testing. At the
end of the third quadrant, the next version of the software is available.
• In the evaluation phase, the software is evaluated to determine if it meets the customer's
requirements and if it is of high quality.
• In the fourth quadrant, the Customers evaluate the so-far developed version of the software. In the
end, planning for the next phase is started.
• The next iteration of the spiral begins with a new planning phase, based on the results of the
evaluation.
• Risk Handling: The projects with many unknown risks that occur as the development proceeds,
in that case, Spiral Model is the best development model to follow due to the risk analysis and risk
handling at every phase.
• Good for large projects: It is recommended to use the Spiral Model in large and complex
projects.
• Customer Satisfaction: Customers can see the development of the product at the early phase of
the software development.
• Complex: The Spiral Model is much more complex than other SDLC models.
• Too much dependability on Risk Analysis: The successful completion of the project is very
much dependent on Risk Analysis. Without very highly experienced experts, it is going to be a
failure to develop a project using this model.
• Difficulty in time management: As the number of phases is unknown at the start of the project,
time estimation is very difficult.
• IBM first proposed the Rapid Application Development or RAD Model in the 1980s. The RAD
model is a type of incremental process model in which there is a concise development cycle. The
RAD model is used when the requirements are fully understood, and the component-based
construction approach is adopted. Various phases in RAD are Requirements
Gathering, Analysis and Planning, Design, Build or Construction, and finally Deployment.
• Requirements Planning - This involves the use of various techniques used in requirements
elicitation like brainstorming, task analysis, form analysis, user scenarios, FAST (Facilitated
Application Development Technique), etc. It also consists of the entire structured plan describing
the critical data, methods to obtain it, and then processing it to form a final refined model.
• User Description - This phase consists of taking user feedback and building the prototype using
developer tools. In other words, it includes re-examination and validation of the data collected in
the first phase. The dataset attributes are also identified and elucidated in this phase.
• Construction - In this phase, refinement of the prototype and delivery takes place. It includes the
actual use of powerful automated tools to transform processes and data models into the final
working product. All the required modifications and enhancements are to be done in this phase.
• The use of reusable components helps to reduce the cycle time of the project.
• The use of powerful development tools results in better quality products in comparatively shorter
periods.
• The use of powerful and efficient tools requires highly skilled professionals.
• The absence of reusable components can lead to the failure of the project.
• The team leader must work closely with the developers and customers to close the project on time.
• The systems which cannot be modularized suitably cannot use this model.
• Feedback is provided by the users on the product for the planning stage of the next cycle and the
development team responds, often by changing the product, plan, or process.
• The number of chunks is huge and is the number of deliveries made to the customer.
• The main advantage is that the customer’s confidence increases as he constantly gets quantifiable
goods or services from the beginning of the project to verify and validate his requirements.
• The model allows for changing requirements as well as all work is broken down into maintainable
work chunks.
• Early and Gradual Distribution: Functional components or prototypes can be delivered early
thanks to incremental development. Faster user satisfaction and feedback may result from this.
• User Commentary and Involvement: Evolutionary models place a strong emphasis on ongoing
user input and participation. This guarantees that the software offered closely matches the needs
and expectations of the user.
• Dependence on an Expert Group: A knowledgeable and experienced group that can quickly
adjust to changes is needed for evolutionary models. Teams lacking experience may find it
difficult to handle these model's dynamic nature.
Aspect Details
Approach Extension of Waterfall with parallel testing
Phases Each dev phase has a corresponding test phase
Emphasizes testing at every stage, better defect
Strengths
prevention
Same rigidity as Waterfall, not suitable for
Weaknesses
iterative projects
Safety-critical applications (e.g., aerospace,
Best For
medical)
Aspect Details
Approach Product is developed in increments/modules
Multiple Waterfall cycles; each increment adds
Phases
functionality
Delivers working software early, easier testing
Strengths
and debugging
Needs good planning; later increments may
Weaknesses
require redesign
Projects where requirements are known but can
Best For
evolve
Aspect Details
Approach Repeats phases to refine the product
Each cycle includes planning, design, coding,
Phases
testing
Strengths Flexible, changes can be made at any stage
Risk of scope creep, requires strong user
Weaknesses
involvement
Large, complex projects where requirements
Best For
evolve over time
Aspect Details
Approach Risk-driven iterative model
Planning → Risk analysis → Engineering →
Phases
Evaluation (repeats in spirals)
Focuses on risk management, good for high-risk
Strengths
projects
Weaknesses Expensive, complex to manage
Best For Large, high-budget, high-risk projects
Aspect Details
Iterative and incremental with customer
Approach
collaboration
Short iterations (Sprints): Plan → Design →
Phases
Code → Test → Deliver
Highly flexible, fast delivery, customer feedback-
Strengths
driven
Hard to predict effort, less documentation, needs
Weaknesses
skilled teams
Dynamic projects with frequently changing
Best For
requirements
Aspect Details
Prototype-based, iterative, with fast development
Approach
cycles
Requirements planning → User design
Phases (prototyping) → Construction → Cutover (final
deployment)
• Fast delivery
• Frequent user feedback
Strengths • Reduced development time
• Focuses on reusability of components