1. Traditional/Plan-Driven Techniques

1. Waterfall
   • Description: A linear, sequential approach where each phase (requirements, design, implementation, testing, deployment) must be completed before the next begins.
   • Use Case: Projects with fixed requirements and minimal changes expected (e.g., government contracts).
   • Key Traits: Rigid structure, extensive documentation, clear milestones.
2. V-Model
   • Description: Extends Waterfall by linking each development stage to a corresponding testing phase (e.g., requirements → acceptance testing).
   • Use Case: Safety-critical systems (e.g., aerospace, medical devices).
   • Key Traits: Emphasis on validation and verification, reduces defects early.
3. Spiral Model
   • Description: Combines iterative development with risk analysis. Cycles (spirals) include planning, risk assessment, prototyping, and evaluation.
   • Use Case: Large, complex projects with uncertain requirements (e.g., R&D).
   • Key Traits: Risk-driven, flexible, integrates prototyping.
4. Incremental Model
   • Description: Divides the project into small increments, each delivering a functional subset of features.
   • Use Case: Projects needing early delivery of partial functionality.
   Key Traits: Progressive development, reduces initial delivery risk.>

2. Agile Techniques

1. Scrum
   • Description: Iterative framework using fixed-length sprints (2–4 weeks). Roles include Product Owner, Scrum Master, and Development Team.
   • Use Case: Dynamic projects requiring frequent feedback (e.g., SaaS products).
   • Key Traits: Sprint planning, daily standups, backlog refinement.
2. Kanban
   • Description: Visual workflow management using a board to track work items (To Do, In Progress, Done). Limits work-in-progress (WIP) to optimize flow.
   • Use Case: Maintenance projects or continuous delivery environments.
   • Key Traits: Flexibility, real-time tracking, no fixed iterations.
3. Extreme Programming (XP)
   • Description: Focuses on technical excellence via practices like Test-Driven Development (TDD), pair programming, and continuous integration.
   • Use Case: Projects requiring high-quality code and rapid adaptation.
   • Key Traits: Customer-centric, frequent releases, automated testing.
4. Lean Development
   • Description: Derived from manufacturing principles, emphasizes eliminating waste (e.g., overproduction, delays) and optimizing efficiency.
   • Use Case: Startups or projects with resource constraints.
   • Key Traits: Value stream mapping, continuous improvement (Kaizen).
5. Feature-Driven Development (FDD)
   • Description: Model-driven approach that prioritizes feature delivery in short cycles (e.g., 2 weeks).
   • Use Case: Large teams needing scalable Agile practices.
   • Key Traits: Feature lists, domain object modeling, progress tracking.

3. Hybrid & Modern Techniques

1. DevOps
   • Description: Combines development (Dev) and operations (Ops) to automate and streamline CI/CD pipelines, fostering collaboration.
   • Use Case: Organizations aiming for rapid, reliable software delivery.
   • Key Traits: Infrastructure as Code (IaC), monitoring, CI/CD tools.
2. Rapid Application Development (RAD)
   • Description: Prioritizes rapid prototyping over strict planning. Uses tools to accelerate development.
   • Use Case: Projects needing quick turnaround (e.g., MVPs).
   • Key Traits: User involvement, reusable components.
3. Adaptive Software Development (ASD)
   • Description: Embraces uncertainty with cycles of speculate, collaborate, and learn.
   • Use Case: Highly dynamic environments (e.g., startups).
   • Key Traits: Mission-driven, risk-tolerant.

4. Supporting Practices

1. Test-Driven Development (TDD)
   • Description: Write tests before code, ensuring functionality meets requirements.
   • Benefits: Reduced bugs, improved design, documentation via tests.
2. Behavior-Driven Development (BDD)
   • Description: Extends TDD with natural language specifications (e.g., Gherkin syntax: Given/When/Then).
   • Benefits: Aligns technical and non-technical stakeholders.
3. Continuous Integration/Continuous Delivery (CI/CD)
   • Description: Automate code integration, testing, and deployment.
   • Benefits: Faster releases, early bug detection.
4. Pair Programming
   • Description: Two developers collaborate at one workstation (driver and navigator).
   • Benefits: Knowledge sharing, higher code quality.

5. Choosing the Right Technique

• Project Requirements: Stable (Waterfall) vs. evolving (Agile).
• Team Size: Large (FDD) vs. small (XP).
• Risk Tolerance: High-risk (Spiral) vs. low-risk (Kanban).
• Industry: Regulated (V-Model) vs. tech-driven (DevOps).

By aligning techniques with project needs, teams can optimize efficiency, quality, and stakeholder satisfaction. Hybrid approaches (e.g., Scrumban) are increasingly popular for balancing structure and flexibility.