Software Development Life Cycle (also called SDLC) is a workflow process which defines the core stages and activities of development cycles or A framework that describes the activities performed at each stage of a software development project.

Software Development Life Cycle (SDLC) is a process used by the software industry to design, develop and test high-quality software’s.

The SDLC aims to produce high-quality software that meets or exceeds customer expectations, reaches completion within times and cost estimates.

System analysts can use it, designers and developers to plan and implement the applications and deliver the systems or products on time and within budget.

With numerous development methodologies, it is never an easy task to choose an appropriate strategy that sometimes even it is inevitable to mix-and-match multiple methods to fit in a single project.

SDLC Phases are as follows
1. Project Initiation
2. Requirements Gathering
3. Analysis
4. Design
5. Development
6. Testing
7. Implementation or deployment
8. Maintenance

The following figure shows the details process of Software Development Life Cycle,

Project Initiation

This is the first stage in the Software Development Life Cycle where the project is initiated.
The high-level scope, problems and solutions are determined, and planning is carried out accordingly for other stages.

Other components that are to be considered in this stage are Resources, time/schedules, milestones, cost, business benefits and deadlines.

In the case of enhancements to existing projects, the strengths and weaknesses of the current software are studied, and the improvements are set as a goal, along with the collected requirements.

Extensibility:
Other components that are to be considered in this stage are Resources, time/schedules, milestones, cost, business benefits and deadlines.
In the case of enhancements to existing projects, the strengths and weaknesses of the current software are studied, and the improvements are set as a goal, along with the collected requirements.

Requirements Gathering

Business requirements are gathered.
Meetings with project managers and stakeholders.
Identify
• “Who will use the system”
• “How the system should work “
• “What should be the input & output of the system”
Analyze requirements for validity & incorporation of requirements
Finally, prepare Requirement specification document
The requirements are of the type:
• Functional Requirements
• Non-functional Requirements
The end-user requirements from the customer and other stakeholders (salespeople, domain/industry experts, etc.) are collected.
Requirements are gathered using the following techniques:
• By conducting Interviews
• By conducting Workshops
• By conducting Surveys and questionnaires
• Focus Groups
• Observations / time study
• By conducting Brainstorming Sessions
• Document Analysis (Ex: Regulatory requirements)
• Mind Mapping
• Benchmarks

Analysis

The Analysis Phase is where you break down the deliverables in the high-level Project Charter into the more detailed business requirements. The Analysis Phase is also the part of the project where you identify the overall direction that the project will take through the creation of the project strategy documents.

• Understand the business need and processing needs
• Gather, analyze, and validate the information.
• Define the requirements and prototypes for the new system.
• Evaluate the alternatives and prioritize the requirements.
• Examine the information needs of end-user and enhances the system goal.
• A Software Requirement Specification (SRS) document is used in the analysis phase, which specifies the software, hardware, functional, and network requirements of the system is prepared at the end of this phase.
• In this, every achievable requirement is anlyzed and documented as Software Requirements Specifications (SRS) or Functional Requirements Specifications (FRS).
• This is effectively manageable for all the resources (developers, designers, testers, project managers and any other possible roles) to work on the chunks at all the stages in the Software Development Life Cycle.
• In many cases, a requirement gathering, and analysis can be carried out at the same time.

System Design

• This is the stage which stated, “How to achieve what is needed?”
• Software Requirements Specifications (SRS) are now transformed to the system design plan, which contains a detailed and complete set of specifications, commonly known as “Design Specification”.
• Prepare design of network, databases, application, system interfaces, user interfaces, system and software design from software requirement specification.
• All the technical details like technologies to use, project constraints, team’s capability, etc. goes into the design specification document.
• The technical architects and developers develop the logical plan of the system which is then reviewed by all the stakeholders.
• Design a contingency, training, maintenance, and operation plan.
• At last, prepare a design document which will be used during next phases.

Development

• Taking all the detailed design documents from the design phase and transforming them into the actual system.
• Build the technical architecture
• Build the database and program
• This stage in more straightforward terms is where the “real work begins” and we “build what is needed”.
• The developers start to code as per the requirements and the developed design.
• Along with the coding, all the other required set-up will begin. i.e., the database set up by database admin, interface and GUI creation by front-end developers, etc.
• Along with coding, it is also essential for developers to develop unit tests for their module, peer review other module’s unit tests, deploy builds to the intended environment and execute unit tests.

Testing

• This stage is the one where the quality check takes place. The developed software is assessed to ensure that all the specified requirements are met.
• Write the test condition and perform the testing of the system.
• This stage is used to validate whether the application addresses all User Requirements, technical performance.
• This is performed by the testing team, and the focus is to find the defects.
• During test case execution, all the error found which are reported in the test management tool and the decision of considering the defect as Valid or Invalid depends on developers.
• Each defect that is found will have to go through the Defect Life Cycle in the defect management tool.
• Again, the testing approach that the project choose depends on various factors: the complexity of the project, the team’s capability, time, etc.

Deployment or Implementation

• Write detailed user documentation and provide training for the system user.
• Once the testing is completed and, there are no open high priority issues, then comes the time to deploy the build to the Production environment. This is the environment which is accessible by real users. Real users can then use the software as per their needs.
• Deploying the build to production can be a complicated process. If the project is an existing application, technology migration is being carried out etc, it can be an extensive procedure.
• Depending on business criticality deployment teams may need to ensure that the application continues to function, while the deployment is in progress.
• Due to the high cut-over time, the Production deployment usually takes place during non-peak hours and / or weekends.

Maintenance

• This stage is when the “fine tuning” of the software takes place. Once the build is deployed to Production environment, any issues that the real users face are considered as Post-Production issues.
• These Post-Production issues are addressed and resolved by the internal team usually termed as Maintenance team.
• This stage also addresses minor change requests, code fixes, etc. and deploys them in short intervals.
• Build a helpdesk to support the system user.
• One may change the application without impairing existing functionalities.
• You may add new functionalities to the existing application.
• You can fix any historical defects of the application in this phase

                Roles and Responsibilities of Business Analyst

Why there is a Software Development Life Cycle necessary?

Software Development Life Cycle is needed in any of the project for the below reasons:
• Enhance the quality of the software
• Define the goals to the team so that developers know what to build and testers know what and how to test
• Reduce the rate of vulnerabilities (fewer or none)
• Management control
• Effective documentation and reduced dependencies
• Effective resource utilization
• Effective cost and time definition
• Ensure the architecture and design are secure
• Define and adhere to the set processes and objectives
• Meet and exceed Customer’s expectation

Software Development Life Cycle Models :

Some of the SDLC Models are as follows :
• Waterfall Model
• Spiral
• V Model
• Prototype
• Agile
• The other related models are Agile Model, Rapid Application Development, Rational Unified Model, Hybrid Model etc.