# BMAD Method: Common Use Cases

This guide provides practical examples of how to use the BMAD Method for common software development scenarios. Each use case includes step-by-step instructions, persona selection guidance, and expected outcomes.

## 1. Starting a New Project

### Scenario
You need to create a new web application from scratch and want to ensure proper planning and architecture.

### BMAD Method Approach

#### Step 1: Requirements Definition with John (Product Manager)
```
# Activation
I need John to help define requirements for a new [type] application.

# Context
We need to build a [description of application]. The target users are [user types].
Key features should include [list initial ideas].
```

**Expected Output**: Comprehensive PRD with user needs, market analysis, feature requirements, and roadmap.

#### Step 2: Market Research with Analyst (Business Analyst)
```
# Activation
I need Analyst to research the market for our [type] application.

# Context
[Share John's PRD]
Please analyze the competitive landscape and identify opportunities for differentiation.
```

**Expected Output**: Market analysis, competitor comparison, and strategic recommendations.

#### Step 3: System Architecture with Fred (System Architect)
```
# Activation
I need Fred to design the architecture for our [type] application.

# Context
[Share PRD and market analysis]
Design a scalable architecture that supports our requirements and allows for future growth.
```

**Expected Output**: System architecture diagram, component specifications, technology stack recommendations, and data flow design.

#### Step 4: UI/UX Design with Veronica (UX/UI Architect)
```
# Activation
I need Veronica to design the user interface for our [type] application.

# Context
[Share PRD and architecture]
Create a user-friendly interface that aligns with our requirements and technical architecture.
```

**Expected Output**: UI mockups, component designs, user flow diagrams, and design system specifications.

#### Step 5: Development Planning with Sarah (Product Owner)
```
# Activation
I need Sarah to create user stories for our [type] application.

# Context
[Share PRD, architecture, and UI designs]
Break down these requirements into sprint-ready user stories with acceptance criteria.
```

**Expected Output**: Prioritized backlog of user stories with acceptance criteria and definition of done.

**Total Time**: 2-3 hours
**Value**: Complete project foundation with alignment across business, technical, and user experience domains.

## 2. Feature Enhancement

### Scenario
You need to add a new feature to an existing application while ensuring compatibility and quality.

### BMAD Method Approach

#### Step 1: Feature Definition with John (Product Manager)
```
# Activation
I need John to help define requirements for adding [feature] to our existing application.

# Context
Our application currently [describe current state].
We need to add [feature] to address [business need].
```

**Expected Output**: Feature specification with user needs, success criteria, and integration requirements.

#### Step 2: Architecture Review with Fred (System Architect)
```
# Activation
I need Fred to review our architecture for adding [feature].

# Context
[Share feature specification and current architecture]
How should we integrate this new feature while maintaining system integrity?
```

**Expected Output**: Architecture update recommendations, integration approach, and technical considerations.

#### Step 3: User Story Creation with Sarah (Product Owner)
```
# Activation
I need Sarah to create user stories for implementing [feature].

# Context
[Share feature specification and architecture recommendations]
Create sprint-ready stories for this feature implementation.
```

**Expected Output**: Detailed user stories with acceptance criteria and technical notes.

#### Step 4: Implementation with David (Developer)
```
# Activation
I need David to implement [specific story] for our [feature].

# Context
[Share user story and technical context]
Implement this functionality using our existing tech stack [details].
```

**Expected Output**: Production-ready code with tests and documentation.

**Total Time**: 1-2 hours
**Value**: Structured feature addition with technical alignment and quality assurance.

## 3. Technical Debt Reduction

### Scenario
Your application has accumulated technical debt that needs to be addressed to improve maintainability and performance.

### BMAD Method Approach

#### Step 1: Technical Assessment with Fred (System Architect)
```
# Activation
I need Fred to assess our technical debt in [system/component].

# Context
Our [system/component] is experiencing [issues].
We suspect problems with [specific areas].
```

**Expected Output**: Technical debt assessment, prioritized issues, and remediation recommendations.

#### Step 2: Refactoring Plan with David (Developer)
```
# Activation
I need David to create a refactoring plan for [system/component].

# Context
[Share technical debt assessment]
Create a step-by-step plan to address these issues while minimizing disruption.
```

**Expected Output**: Detailed refactoring plan with code examples, testing strategy, and risk mitigation.

#### Step 3: Quality Assurance with SM (Scrum Master)
```
# Activation
I need SM to create a quality assurance process for our refactoring effort.

# Context
[Share refactoring plan]
Help us ensure quality throughout this refactoring process.
```

**Expected Output**: QA process, review checkpoints, and validation strategy.

**Total Time**: 1-2 hours
**Value**: Structured approach to technical debt reduction with minimal risk.

## 4. Performance Optimization

### Scenario
Your application is experiencing performance issues that need to be diagnosed and resolved.

### BMAD Method Approach

#### Step 1: Performance Analysis with Fred (System Architect)
```
# Activation
I need Fred to analyze performance issues in our [system/component].

# Context
Our [system/component] is experiencing [specific performance issues].
Here are our current metrics: [performance data].
```

**Expected Output**: Performance bottleneck analysis, root cause identification, and optimization recommendations.

#### Step 2: Optimization Implementation with David (Developer)
```
# Activation
I need David to implement performance optimizations for [specific issue].

# Context
[Share performance analysis]
Implement the recommended optimizations while maintaining functionality.
```

**Expected Output**: Optimized code with before/after performance metrics and testing strategy.

#### Step 3: Infrastructure Optimization with DevOps-PE (DevOps Engineer)
```
# Activation
I need DevOps-PE to optimize our infrastructure for [performance requirements].

# Context
[Share performance analysis and code optimizations]
Recommend and implement infrastructure improvements to support our performance goals.
```

**Expected Output**: Infrastructure optimization plan, configuration changes, and monitoring setup.

**Total Time**: 1-2 hours
**Value**: Comprehensive performance improvement across application and infrastructure.

## 5. Cross-Functional Problem Solving

### Scenario
You're facing a complex problem that spans multiple domains (business, technical, UX, etc.).

### BMAD Method Approach

#### Step 1: Problem Definition with John (Product Manager)
```
# Activation
I need John to help define the problem of [issue description].

# Context
We're experiencing [problem] which affects [business impact].
We need a solution that addresses [key requirements].
```

**Expected Output**: Problem statement, business impact analysis, and solution requirements.

#### Step 2: Multi-Perspective Analysis
```
# Activation (Sequential)
I need Analyst to analyze business implications of [problem].
I need Fred to analyze technical implications of [problem].
I need Veronica to analyze user experience implications of [problem].
```

**Expected Output**: Comprehensive analysis from business, technical, and UX perspectives.

#### Step 3: Solution Design with Fred (System Architect)
```
# Activation
I need Fred to design a solution for [problem].

# Context
[Share all previous analyses]
Design a solution that addresses all these perspectives and requirements.
```

**Expected Output**: Integrated solution design with technical, business, and UX considerations.

#### Step 4: Implementation Planning with Sarah (Product Owner)
```
# Activation
I need Sarah to create an implementation plan for this solution.

# Context
[Share solution design]
Break this down into implementable stories and create a delivery plan.
```

**Expected Output**: Implementation roadmap with prioritized stories and delivery timeline.

**Total Time**: 2-3 hours
**Value**: Holistic solution that addresses complex problems across multiple domains.

## 6. Legacy System Modernization

### Scenario
You need to modernize a legacy system while maintaining functionality and minimizing disruption.

### BMAD Method Approach

#### Step 1: System Assessment with Fred (System Architect)
```
# Activation
I need Fred to assess our legacy [system/component] for modernization.

# Context
Our legacy system [description] needs modernization because [reasons].
Current pain points include [issues].
```

**Expected Output**: Legacy system assessment, modernization opportunities, and technical approach recommendations.

#### Step 2: Modernization Strategy with John (Product Manager)
```
# Activation
I need John to create a modernization strategy for our legacy system.

# Context
[Share system assessment]
Help us prioritize modernization efforts based on business impact and technical feasibility.
```

**Expected Output**: Modernization roadmap with phased approach and business justification.

#### Step 3: Migration Planning with DevOps-PE (DevOps Engineer)
```
# Activation
I need DevOps-PE to create a migration plan for our legacy system.

# Context
[Share system assessment and modernization strategy]
Design a migration approach that minimizes downtime and risk.
```

**Expected Output**: Detailed migration plan with environment setup, testing strategy, and rollback procedures.

#### Step 4: Implementation with David (Developer)
```
# Activation
I need David to implement the first phase of our modernization plan.

# Context
[Share all previous outputs]
Implement the [specific component] modernization following our technical approach.
```

**Expected Output**: Modernized code with migration scripts, tests, and documentation.

**Total Time**: 2-3 hours
**Value**: Structured modernization approach with minimized risk and business alignment.

## 7. Rapid Prototyping

### Scenario
You need to quickly validate a new idea or concept with a working prototype.

### BMAD Method Approach

#### Step 1: Concept Definition with John (Product Manager)
```
# Activation
I need John to help define a prototype for [concept].

# Context
We want to validate [idea/concept] with a quick prototype.
The key aspects to demonstrate are [features].
```

**Expected Output**: Prototype specification with core features and validation criteria.

#### Step 2: UI Design with Veronica (UX/UI Architect)
```
# Activation
I need Veronica to design a prototype UI for [concept].

# Context
[Share prototype specification]
Create a simple but effective UI that demonstrates the core concept.
```

**Expected Output**: Prototype UI design with key screens and interactions.

#### Step 3: Rapid Implementation with David (Developer)
```
# Activation
I need David to implement a working prototype for [concept].

# Context
[Share prototype specification and UI design]
Create a functional prototype optimized for speed rather than production quality.
```

**Expected Output**: Working prototype code with setup instructions and limitations noted.

**Total Time**: 1-2 hours
**Value**: Functional prototype to validate concepts quickly before full investment.

## 8. Documentation Generation

### Scenario
You need comprehensive documentation for your system or API.

### BMAD Method Approach

#### Step 1: Documentation Planning with Fred (System Architect)
```
# Activation
I need Fred to plan documentation for our [system/API].

# Context
We need documentation for [audience] covering [scope].
Current system details: [brief description]
```

**Expected Output**: Documentation plan with structure, content requirements, and format recommendations.

#### Step 2: Technical Documentation with David (Developer)
```
# Activation
I need David to create technical documentation for [component/API].

# Context
[Share documentation plan]
Create detailed technical documentation including examples and best practices.
```

**Expected Output**: Comprehensive technical documentation with code examples and usage guidelines.

#### Step 3: User Documentation with Veronica (UX/UI Architect)
```
# Activation
I need Veronica to create user documentation for [feature/system].

# Context
[Share documentation plan]
Create user-friendly documentation with visual guides and examples.
```

**Expected Output**: User-focused documentation with screenshots, workflows, and troubleshooting guides.

**Total Time**: 1-2 hours
**Value**: Complete documentation suite tailored to different audiences.

## Best Practices for All Use Cases

1. **Maintain Context Continuity**: Share outputs between personas to maintain context
2. **Be Specific in Requests**: Clearly define what you need from each persona
3. **Provide Relevant Background**: Include necessary project context and constraints
4. **Iterate When Needed**: Don't hesitate to ask for refinements or alternatives
5. **Combine Personas for Complex Tasks**: Use multiple personas for challenging problems
6. **Document Outputs**: Save key outputs for future reference and team sharing
7. **Validate Against Requirements**: Ensure solutions align with original requirements
8. **Consider Integration Points**: Think about how outputs will integrate with existing systems

---

These use cases demonstrate the versatility of the BMAD Method across different software development scenarios. Adapt these approaches to your specific needs and combine personas as required for your unique challenges.
