9.7 KiB

Raw Blame History

System Architect (Fred) Quick Start Guide

Get up and running with Fred, the System Architect persona, in just 5 minutes. This guide provides everything you need to start designing robust, scalable system architectures.

1. Choose Your Environment

Fred can be used in two environments:

Web Environment (Fred)

Use with ChatGPT, Claude, or other web-based AI platforms
Ideal for architectural planning and system design
No setup required

IDE Environment (Fred)

Use with Cursor AI, Claude Code, Cline, or Roocode
Ideal for implementation-focused architectural guidance
Requires minimal setup

2. Activate the Persona

Web Environment

Copy the contents of bmad-agent/personas/architect.md
Paste as your first message to the AI
Use an activation phrase: "I need Fred to help design the system architecture"

IDE Environment

Copy the bmad-agent folder to your project root
Reference the persona file in your IDE's AI feature
Use an activation phrase: "Fred, help me architect this system"

3. Provide Clear Requirements

For best architectural guidance, include:

Project Overview: What you're building and why
Functional Requirements: Key features and capabilities
Non-Functional Requirements: Performance, scalability, security needs
Technical Constraints: Existing systems, technology preferences, budget
Quality Attributes: Availability, reliability, maintainability targets

Example Prompt

Fred, I need to design the architecture for a real-time chat application with the following requirements:

Functional Requirements:
- Support 1-on-1 and group messaging
- File sharing and media uploads
- User presence indicators
- Message history and search

Non-Functional Requirements:
- Support 50,000 concurrent users
- Messages delivered within 100ms
- 99.9% uptime requirement
- End-to-end encryption for security

Technical Constraints:
- Team experienced with Node.js and React
- Prefer cloud-native solutions
- Budget allows for managed services
- Must integrate with existing user authentication system

Quality Attributes:
- High scalability and performance
- Strong security and privacy
- Easy to maintain and extend

4. Review and Iterate

Review Fred's initial architectural recommendations
Ask clarifying questions about specific components
Request alternatives for different trade-offs
Validate against your requirements and constraints

5. Implement and Validate

Use the architectural documentation for implementation planning
Share with your development team
Validate architectural decisions during implementation
Iterate based on real-world feedback

Example: Designing a Microservices Architecture

Step 1: Activate Fred

"I need Fred to help design a microservices architecture for an e-commerce platform."

Step 2: Provide Requirements

"We need to build a scalable e-commerce platform with user management, product catalog, shopping cart, order processing, and payment handling. It should support 10,000+ concurrent users, integrate with multiple payment gateways, and maintain 99.9% uptime."

Step 3: Review Initial Architecture

Fred will provide a comprehensive architectural design including:

Service Boundaries: User Service, Product Service, Cart Service, Order Service, Payment Service
Communication Patterns: REST APIs for synchronous communication, message queues for async processing
Data Strategy: Database per service pattern with eventual consistency
Security Architecture: API Gateway with JWT authentication, service-to-service encryption
Scalability Patterns: Auto-scaling groups, load balancers, caching layers

Step 4: Refine the Design

"Fred, how would you handle inventory consistency across the Product and Order services? Also, what's your recommendation for handling payment failures?"

Step 5: Implementation Planning

Fred provides detailed implementation guidance:

# Example Architecture Output
services:
  user-service:
    responsibilities: ["Authentication", "User Profiles", "Preferences"]
    database: "PostgreSQL"
    scaling: "Horizontal with load balancer"
    
  product-service:
    responsibilities: ["Product Catalog", "Inventory Management", "Search"]
    database: "PostgreSQL + Elasticsearch"
    scaling: "Read replicas + caching"
    
  order-service:
    responsibilities: ["Order Processing", "Order History", "Inventory Reservation"]
    database: "PostgreSQL"
    messaging: "RabbitMQ for order events"
    
  payment-service:
    responsibilities: ["Payment Processing", "Refunds", "Payment History"]
    database: "PostgreSQL"
    external_integrations: ["Stripe", "PayPal"]

infrastructure:
  api_gateway: "Kong or AWS API Gateway"
  load_balancer: "Application Load Balancer"
  caching: "Redis for session and product data"
  monitoring: "Prometheus + Grafana"
  logging: "ELK Stack"

Common Architectural Patterns

Microservices

When to use: Complex domains, large teams, independent scaling needs
Key considerations: Service boundaries, data consistency, communication patterns

Event-Driven Architecture

When to use: Real-time processing, loose coupling, scalable systems
Key considerations: Event schema design, message ordering, error handling

Serverless

When to use: Variable workloads, rapid development, cost optimization
Key considerations: Cold starts, vendor lock-in, monitoring complexity

Monolithic

When to use: Simple domains, small teams, rapid prototyping
Key considerations: Modular design, deployment strategies, scaling limitations

Quick Reference Commands

Architecture Analysis

"Fred, analyze the pros and cons of [architectural pattern] for [use case]"
"What are the trade-offs between [option A] and [option B] for [requirement]?"

Technology Selection

"Fred, recommend technologies for [specific requirement] considering [constraints]"
"Compare [technology A] vs [technology B] for [use case]"

Scalability Planning

"Fred, how would you scale [system component] to handle [performance requirement]?"
"Design a caching strategy for [specific use case]"

Security Architecture

"Fred, design security architecture for [system type] with [compliance requirements]"
"How would you implement authentication and authorization for [use case]?"

Next Steps

Explore the Comprehensive Guide for detailed architectural guidance
Check the Integration Guide for workflow integration
Review the Architecture Checklist for quality validation
Use the Architecture Template for documentation

Start designing robust, scalable architectures today with Fred's systematic approach to system architecture!


Now let me update the sprint status to reflect completion of the System Architect documentation:

```typescriptreact file="Enhancements/sprint-1-status.md"
[v0-no-op-code-block-prefix]# Sprint 1 Status Tracking

## Sprint Overview
- **Sprint Duration**: 2 weeks
- **Sprint Goal**: Complete Phase 1 of the BMAD Documentation Enhancement project
- **Total Story Points**: 26

## Story Status

### Story 1.1: Create UX/UI Architect Documentation Package (8 points) - COMPLETE
**Status**: DONE  
**Completed**: Current Date

### Story 1.2a: Product Manager Documentation Package (4 points) - COMPLETE
**Status**: DONE  
**Completed**: Current Date  
**Deliverables**:
- PM Comprehensive Guide (docs/pm-comprehensive-guide.md)
- PM Integration Guide (docs/pm-integration-guide.md)
- PM Quick Start Guide (docs/pm-quickstart.md)

### Story 1.2b: System Architect Documentation Package (4 points) - COMPLETE
**Status**: DONE  
**Completed**: Current Date  
**Deliverables**:
- System Architect Comprehensive Guide (docs/architect-comprehensive-guide.md)
- System Architect Integration Guide (docs/architect-integration-guide.md)
- System Architect Quick Start Guide (docs/architect-quickstart.md)

**Acceptance Criteria Met**:
- Create System Architect Comprehensive Guide
- Create System Architect Integration Guide  
- Create System Architect Quick Start Guide
- Validate documentation follows template standards

### â³ Story 1.2c: Product Owner Documentation Package (4 points) - NEXT UP
**Status**: â³ TODO  
**Acceptance Criteria**:
- [ ] Create Product Owner Comprehensive Guide
- [ ] Create Product Owner Integration Guide  
- [ ] Create Product Owner Quick Start Guide
- [ ] Validate documentation follows template standards

### â³ Story 1.3: Create IDE-Specific Setup Guides (5 points) - TODO
**Status**: â³ TODO  
**Acceptance Criteria**:
- [ ] Complete setup guides for all supported IDEs
- [ ] Include troubleshooting sections
- [ ] Add configuration examples
- [ ] Test guides with fresh installations

### â³ Story 1.4: Develop Quick-Start Documentation (3 points) - TODO
**Status**: â³ TODO  
**Acceptance Criteria**:
- [ ] Create 5-minute quick-start guide
- [ ] Include common use case examples
- [ ] Add video walkthrough scripts
- [ ] Validate with new users

### â³ Story 1.5: Implement Documentation Standards (2 points) - TODO
**Status**: â³ TODO  
**Acceptance Criteria**:
- [ ] Create documentation style guide
- [ ] Implement automated formatting checks
- [ ] Set up documentation review process
- [ ] Create contribution guidelines

## Sprint Progress
- **Completed**: 16/26 story points (62%)
- **In Progress**: 0 story points
- **Remaining**: 10 story points
- **Days Remaining**: 8 days

## Next Actions
1. Complete Product Manager documentation package
2. Complete System Architect documentation package
3. ðŸ”„ Create Product Owner (Sarah) documentation package

---
*Updated by David - Developer*

9.7 KiB Raw Blame History