About SDLC

• About SDLC

• Models of SDLC

• Brief about all models except agile

here is the full breakdown - https://youtu.be/6_JT8D56lms

About SDLC

Breakdown SDLC:

SD- software development

LC - Lifecycle

SDLC (Software Development Life Cycle) is a structured process used to design, develop, test, and deploy software. It ensures software is built systematically, reducing risks and improving quality.

Models of SDLC

Time Period	SDLC Model	Description
1950s - 1970s	Waterfall Model	First structured SDLC model, sequential and rigid.
1970s - 1980s	V-Model	Extension of Waterfall with testing at each stage.
1980s - 1990s	Spiral Model	Risk-driven iterative model with refinement cycles.
1980s - 1990s	Prototype Model	Focused on building an early sample for validation.
1990s	RAD Model	Rapid prototyping with iterative feedback.
1990s - 2000s	Incremental Model	Development in small, manageable parts.
2000s - 2010s	Agile Model	Iterative, flexible, customer-focused approach.
2010s - Present	DevOps Model	Continuous integration, deployment, and automation.
2017 - Present	DevSecOps(Ai-ops)	Continuous integration, deployment, and automation with built-in security.

Brief about other models

1. Waterfall Model (1950s - 1970s)

Definition:

A sequential software development model where each phase must be completed before moving to the next.

Phases:

1. Requirement Analysis – Gather and document requirements.

2. System Design – Plan architecture and system design.

3. Implementation (Coding) – Developers write code based on the design.

4. Testing – Verify software functionality.

5. Deployment – Release software to users.

6. Maintenance – Fix issues and provide updates.

Advantages:

• Simple and easy to manage.

• Well-structured and documented.

• Suitable for projects with well-defined requirements.

Disadvantages:

• Rigid, difficult to accommodate changes.

• Testing occurs late in the process, leading to delays in finding issues.

• Not ideal for complex or evolving projects.

When to Use:

• Small projects with well-defined, fixed requirements.

• Where documentation and approvals are necessary.

V-Model (Verification & Validation Model - 1970s - 1980s)

V-Model (Verification and Validation Model)

Definition:

The V-Model (Validation & Verification Model) is a software development model that emphasizes testing at each development phase. It is an extension of the Waterfall Model, where testing activities are planned in parallel with development activities. It ensures that each development phase has a corresponding testing phase, making defect detection easier and earlier in the lifecycle.

Phases of the V-Model

1. Verification Phases (Development Side)

These phases focus on defining and designing the system:

1. Requirement Analysis – Gather and analyze business requirements.

2. System Design – Create a high-level architecture for the system.

3. High-Level Design (HLD) – Define modules and their interactions.

4. Low-Level Design (LLD) – Define detailed design specifications for individual modules.

5. Implementation (Coding) – Write code for each module.

2. Validation Phases (Testing Side)

These phases ensure that the system meets the specified requirements:

1. Unit Testing – Test individual components (modules).

2. Integration Testing – Test interactions between modules.

3. System Testing – Validate the complete system against requirements.

4. Acceptance Testing – Ensure the system meets business needs and user expectations.

Advantages of V-Model

• Early defect detection – Testing starts from the requirement phase, reducing cost and effort in fixing defects.

• Well-structured and disciplined approach – Clearly defined phases make project tracking easier.

• High quality due to systematic verification and validation – Each development phase is tested against requirements.

• Better risk management – Since testing is integrated from the start, potential risks are identified early.

Disadvantages of V-Model

• Not flexible – Changes in requirements are difficult to accommodate once development starts.

• High initial cost and effort – Since testing is emphasized early, more effort is required upfront.

• Not suitable for complex, dynamic projects – This model is ideal for well-defined projects but struggles with evolving requirements.

When to Use the V-Model?

• When project requirements are well-defined and stable.

• For safety-critical applications (e.g., medical, aerospace, automotive).

• When quality and testing are high priorities.

• When project timelines are strict, and minimal changes are expected.

Why Not the Waterfall Model?

🚫 Waterfall Model follows a linear approach where testing happens only at the end. This leads to:

• Late defect detection, making bug fixes costly.

• Limited flexibility to accommodate changes in requirements.

• Poor risk management, as potential issues are discovered too late.

V-Model is preferred over Waterfall when testing needs to be integrated early to improve software

1. Spiral Model (1980s - 1990s)

The Spiral Model is a software development process that combines iterative development with risk management. It allows for multiple iterations (spirals), where the project progresses through repeated cycles, refining and improving with each loop. The focus is on identifying and mitigating risks early in the development process.

Phases of the Spiral Model

Each iteration of the Spiral Model consists of the following four phases:

1. Planning Phase

   • Gather requirements and identify objectives for the iteration.

   • Estimate resources, schedule, and identify constraints.

2. Risk Analysis Phase

   • Identify potential risks for the iteration.

   • Develop risk mitigation strategies.

   • Conduct feasibility analysis and alternative evaluations.

3. Engineering Phase

   • Design, develop, and implement the features planned in the iteration.

   • Conduct initial testing of the developed modules.

4. Evaluation and Review Phase

   • Evaluate the completed iteration with stakeholders.

   • Gather feedback and plan for the next spiral cycle.

This cycle repeats, incorporating refinements and additional requirements as the project progresses.

Advantages of the Spiral Model

• Risk handling – Identifies and mitigates risks early, making it suitable for complex projects.

• Flexibility – Allows for changes in requirements during development.

• Customer involvement – Stakeholders review each iteration, ensuring alignment with business needs.

• Efficient cost estimation – Provides better cost estimation as the project evolves.

• Continuous refinement – System improves progressively with each iteration.

Disadvantages of the Spiral Model

• High cost and time-consuming – Risk analysis and multiple iterations require significant time and resources.

• Complex process – Managing the iterative cycles and risk assessments requires expertise.

• Not suitable for small projects – Overhead costs make it impractical for smaller software projects.

• Difficult documentation – Continuous changes and refinements make maintaining proper documentation challenging.

When to Use the Spiral Model?

• When project requirements are unclear or evolving.

• When high risk is involved, such as in large and complex applications.

• When continuous refinement and user feedback are needed throughout the development process.

• When prototyping is required to clarify requirements before full-scale development.

• When budget and time allow for iterative cycles and risk analysis.

Why Not the V-Model?

1. V-Model is rigid – It does not accommodate requirement changes once development starts, while the Spiral Model allows flexibility.

2. V-Model does not focus on risk assessment – Spiral Model integrates risk analysis in every phase, making it more suitable for high-risk projects.

3. V-Model is best for smaller, well-defined projects – Spiral Model is better for large, complex, or high-risk projects requiring iterative refinement.

4. Customer involvement is minimal in V-Model – Spiral Model allows continuous stakeholder feedback, reducing misunderstandings in requirements.

Prototype Model (1980s - 1990s)

The Prototype Model involves building a working prototype early in development to gather user feedback, refine requirements, and identify potential issues before full-scale development.

Phases of the Prototype Model

1. Requirement Gathering – Identify user requirements, focusing on unclear areas.

2. Quick Design – Develop an initial, basic prototype with essential features.

3. Prototype Development – Build the prototype quickly using rapid development tools.

4. User Evaluation – Present the prototype to users for feedback.

5. Refinement – Improve the prototype based on user feedback.

1. Final Product Development – Use the refined prototype to develop the final system.

Advantages of the Prototype Model

• Clarifies unclear requirements.

• Allows early user involvement and feedback.

• Reduces development risks by identifying issues early.

• Improves usability based on feedback.

• Speeds up delivery of the final product.

Disadvantages of the Prototype Model

• High cost due to multiple prototypes.

• Risk of scope creep as users request continuous changes.

• Inefficient for projects with clear requirements.

• Prototypes may have quality issues.

When to Use the Prototype Model?

• When requirements are unclear.

• When user feedback is essential.

• When UI/UX is a key focus.

• When a proof of concept is needed.

• When stakeholders need to visualize the system early.

Why Not the Spiral Model?

1. Spiral Model is complex and costly due to detailed risk analysis and multiple iterations.

2. Spiral Model suits large, high-risk projects, while the Prototype Model is better for clarifying requirements.

3. Spiral Model requires expert risk management, which may not be needed in simpler projects.

RAD Model(1990s)

The RAD Model is a software development methodology that prioritizes rapid prototyping and quick feedback from users. It emphasizes quick development and iteration, reducing the overall development time by using tools and techniques to create software components in parallel and integrate them.

Phases of the RAD Model

Advantages of the RAD Model

• Faster development – Rapid prototyping reduces time-to-market.

• User feedback – Continuous user involvement and feedback ensure the system meets their needs.

• High flexibility – Allows easy changes and refinements based on user feedback.

• Improved quality – Early testing and prototypes help identify issues early.

• Cost-effective – Reduces development time and costs due to parallel development.

Disadvantages of the RAD Model

• Requires skilled developers – Fast-paced development requires highly skilled teams.

• Not suitable for large, complex projects – Can be ineffective for large-scale systems due to the challenge of managing multiple prototypes.

• Limited scalability – RAD is better for smaller projects and prototypes.

• Risk of scope creep – Continuous feedback and changes can lead to expanding project scope.

When to Use the RAD Model?

• When quick development is needed and requirements are clear but flexible.

• For small to medium-sized projects that can be rapidly developed.

• When user involvement is crucial for frequent feedback.

• When there are limited resources but a need for fast deployment.

Why Not the Prototype Model?

1. RAD Model is faster – RAD focuses on quick development and iteration, while the Prototype Model can involve multiple prototyping cycles.

2. RAD is more structured – RAD involves clearly defined phases for rapid development, while the Prototype Model is less structured and can lead to scope creep.

3. RAD handles parallel development – RAD works with multiple components in parallel, whereas the Prototype Model focuses on a single prototype at a time.

4. RAD is better suited for projects requiring frequent user feedback and rapid iteration, while the Prototype Model is more focused on initial requirement clarification.

Incremental Model (1990s - 2000s)

Incremental Model is a process of software development where requirements divided into multiple standalone modules of the software development cycle. In this model, each module goes through the requirements, design, implementation and testing phases. Every subsequent release of the module adds function to the previous release. The process continues until the complete system achieved.

Advantages of the Incremental Model

• Delivers a working product early.

• Easier debugging and risk management.

• Allows user feedback for improvements.

• Lower cost compared to full-scale development upfront.

Disadvantages of the Incremental Model

• Requires careful planning and design.

• Integration challenges as new increments are added.

• Increased overall development time compared to RAD.

• Not suitable for projects with rapidly changing requirements.

When to Use the Incremental Model?

• When requirements are well-defined but can evolve.

• When early delivery of functional components is needed.

• For large projects that can be divided into smaller modules.

• When risk management and phased implementation are priorities.

Why Not the RAD Model?

1. RAD focuses on rapid prototyping, while the Incremental Model follows a more structured, phased approach.

2. Incremental Model is better for large projects, whereas RAD is ideal for quick, small-to-medium-sized applications.

3. Incremental Model allows for planned development, while RAD relies heavily on continuous user feedback.

4. RAD is faster, but the Incremental Model ensures stability and long-term scalability.