An outline of the steps taken at each stage of the software development process is

known as the software development life cycle (SDLC). A development team within the
software organization tracks the SDLC design.

It consists of a detailed strategy outlining the creation, upkeep, and replacement of

particular software. The life cycle outlines an approach for enhancing both the general
software development process and the quality of the final product.

Stages of Software Development Life Cycle (SDLC):

Requirement Phase

The most significant stage of the software development lifecycle is the requirement
gathering and analysis phase. Business Analyst collects the requirement from the
The customer/client specifies the requirements in the business requirement
specification (the document's name changes depending on the organization) in
accordance with the client's business demands. Examples include Business
Specification (BS), Customer Requirement Specification (CRS), and others, which are
given to the development team.

Analysis Phase

The next phase is to define and record the product requirements and obtain customer
approval when the requirement collection and analysis have been completed. The SRS
(Software Requirement Specification) document is used to do this. SRS is made up of
all the product requirements that must be created throughout the course of the project.
The Project Manager, Business Analyst, and Senior Team Members are important
participants in this phase. The Software Requirement Specification is the end result of
this process.

Design Phase

It has two level design

HLD – High-Level Design Senior developers and architects work together to provide the
architecture of the software product that will be created.
LLD – Low-Level Design Senior developers handle it. It explains how each and every
feature and component of the product should operate. The code will not be present
here; simply the design will.

The outcome from this phase is a High-Level Document and Low-Level Document
which works as an input to the next phase

Development Phase
This phase involves developers of all experience levels (seniors, juniors, and
beginners). During this stage, we begin writing the product's code and developing the
software. The developed product and the Source Code Document (SCD) are the results
of this phase.

Testing and Integration

When the software is complete, it is delivered to the testing department, where the test
team extensively checks it for various flaws. Depending on the STLC (Software Testing
Life Cycle) process, they either manually test the software or utilize automated testing
tools to make sure every component of the software functions properly. Once the QA
makes sure that the software is error-free, it goes to the next stage, which is
Implementation. The Quality Product and the Testing Artifacts are the results of this
phase. After the application has been tested successfully, we must integrate the
different modules, such as login, signup, upload, claim, and services.

Deployment & Maintenance Phase

The product is provided or deployed to the customer for usage following a successful
test. The deployment and implementation engineers are in charge of deployment. After
the consumers begin utilizing the created system, the actual issues will arise and
require periodic resolution. In the maintenance phase, problems that the customer
discovered are fixed. Because the way testers test the product differs from the way
users use it, 100% testing is not achievable. The SLA should be followed for
maintenance (Service Level Agreement)

Iterative Models:
The iterative models are specific examples of a software development lifecycle that
emphasizes an early, basic implementation before progressively gaining complexity and
a wider feature set until the final system is finished. Improvements in this kind of model
can be seen immediately after being implemented during each iteration. The two
iterative models I'll discuss are the agile and prototype approaches.
Agile model, Please add sprint and scum. Standup meeting, client’s feedback, backlog,
sprint backlog. Please include the manifesto of agile.
The Agile SDLC model combines iterative and incremental process models, with an
emphasis on process adaptability and customer satisfaction through the quick delivery
of functional software. The product is divided into smaller incremental builds using agile
methods. Iterations of these builds are supplied. (n.d, 2018) According to this paradigm,
each project is handled differently and existing techniques are adjusted to better meet
the project's needs. For the purpose of delivering particular features in the release, all
jobs are separated into manageable time spans. Working software and client interaction
are prioritized over thorough documentation and contract negotiations. A cross-
functional team collaborates on each iteration of the project under this paradigm, which
also enables proper responsiveness to change rather than simply following the project
plan.
The agile approach is a collaborative, iterative method of development. This model
places a high priority on the quick delivery of the system in fully operational
components. Instead of setting up tasks and schedules for system development, all time
is time boxed in sprints. Each sprint has a set time limit before it begins, though this can
change depending on the project and the ongoing list of deliverables. When scheduled
work for a sprint cannot be finished, it may be reprioritized again and the information
utilized to plan future sprints. The team and clients analyze and assess the work once it
has been finished. This model relies upon a high level of customer involvement
throughout the development process and it is more especially during reviewing the
system.

There are various phases in the agile model which are illustrated below:

Requirments- Gathering the system requirements is the first stage in this model. A
meeting is held and all choices are put into action because this technique doesn't
require extensive paperwork to gather software requirements.

Design- The software design is being prepared at this stage with the aid of several
software designing tools. It can be ready as a demo version, and as the project
progresses, more crucial features can be added. Customers submit input to the system
in this instance as well, and it is modified to meet their demands.

Development-In this phase, the designed demo version is implemented for user
feedback and the system will virtually be finished. In this stage, customer participation
and input are crucial.
Testing and feedback-The entire system is wrapped up during this last phase, including
all necessary testing. The created system is sent to the client once they are pleased
with it.

Sequential models

In this type of model, developers have to follow some rules, regulations, and defined
orders for completing the project. Here I am going to describe two sequential models of
software development which are the waterfall model and the V model.

Waterfall Model

One of the oldest and most frequently employed software development approaches is
the waterfall model. This life cycle model is frequently referred to as the traditional
approach to software development. The software development process is described in
this model as having a linear sequential flow, meaning that each phase may only start
after the one before it has finished. The procedure for going back to the earlier phase to
accommodate changes in requirements is not specified by this development approach.

As shown in the above figure there are various sequential phases involved in the
waterfall model which are explained below: -
Requirement Gathering and analysis