System Design & Architecture - Building Scalable Foundations

I'm building a [PROJECT_TYPE] with these requirements:
[REQUIREMENTS_LIST]

Expected scale: [USER_COUNT] users, [DATA_VOLUME] data volume

Recommend the best architectural patterns including:
1. Overall system architecture (monolith, microservices, serverless)
2. Database architecture (SQL, NoSQL, hybrid)
3. Caching strategies
4. API design patterns
5. Security architecture
6. Deployment architecture

Provide pros/cons for each recommendation and explain why it fits this specific use case.

For this application: [APP_DESCRIPTION]

With these entities and relationships: [ENTITY_LIST]

Design a comprehensive database schema including:
1. Entity Relationship Diagram (textual description)
2. Table structures with fields, types, and constraints
3. Index recommendations for performance
4. Relationship definitions (one-to-one, one-to-many, many-to-many)
5. Data integrity rules
6. Partitioning strategies for large datasets

Consider both ACID compliance and performance optimization.

Design a RESTful API for: [PROJECT_NAME]

With these core functionalities: [FEATURE_LIST]

Provide:
1. Complete endpoint specifications (HTTP methods, paths, parameters)
2. Request/response schemas in JSON format
3. Authentication and authorization strategy
4. Rate limiting and throttling recommendations
5. Error handling patterns
6. API versioning strategy
7. Documentation structure

Follow REST best practices and modern API design principles.

## System Architecture: SocialConnect

### High-Level Architecture
- **Frontend**: React Native (mobile-first)
- **API Gateway**: Kong or AWS API Gateway
- **Backend Services**: Node.js microservices
- **Database**: PostgreSQL (user data) + Redis (sessions/cache)
- **Real-time**: WebSocket servers with Socket.io
- **File Storage**: AWS S3 for media content
- **CDN**: CloudFlare for global content delivery

### Service Breakdown
1. **User Service**: Authentication, profiles, preferences
2. **Content Service**: Posts, comments, media handling
3. **Messaging Service**: Real-time chat and notifications
4. **Feed Service**: Timeline generation and caching
5. **Analytics Service**: User behavior tracking

-- Users Table
CREATE TABLE users (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email VARCHAR(255) UNIQUE NOT NULL,
    password_hash VARCHAR(255) NOT NULL,
    first_name VARCHAR(100),
    last_name VARCHAR(100),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Products Table
CREATE TABLE products (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    name VARCHAR(255) NOT NULL,
    description TEXT,
    price DECIMAL(10,2) NOT NULL,
    inventory_count INTEGER DEFAULT 0,
    category_id UUID REFERENCES categories(id),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Orders Table
CREATE TABLE orders (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id UUID REFERENCES users(id),
    status VARCHAR(50) DEFAULT 'pending',
    total_amount DECIMAL(10,2),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Analyze this system architecture: [ARCHITECTURE_DESCRIPTION]

Expected load: [TRAFFIC_PATTERNS]

Identify performance bottlenecks and provide optimization strategies for:
1. Database query optimization
2. Caching strategies (Redis, CDN, application-level)
3. Load balancing and horizontal scaling
4. Asynchronous processing patterns
5. Memory and CPU optimization
6. Network latency reduction

Include specific implementation recommendations and monitoring strategies.

Review this system design for security vulnerabilities: [SYSTEM_DESIGN]

Provide a comprehensive security assessment covering:
1. Authentication and authorization flaws
2. Data protection and encryption requirements
3. API security best practices
4. Input validation and sanitization
5. Network security considerations
6. Compliance requirements (GDPR, HIPAA, etc.)
7. Security monitoring and incident response

Suggest specific security controls and implementation guidelines.

Optimize this architecture for [CLOUD_PROVIDER] deployment: [CURRENT_ARCHITECTURE]

Budget constraints: [BUDGET_RANGE]
Performance requirements: [PERFORMANCE_SPECS]

Recommend:
1. Optimal cloud services for each component
2. Cost optimization strategies
3. Auto-scaling configurations
4. Disaster recovery setup
5. Monitoring and alerting configuration
6. CI/CD pipeline architecture
7. Infrastructure as Code templates

Focus on cost-effectiveness while maintaining performance and reliability.

Create an Architecture Decision Record for: [DECISION_TOPIC]

Context: [BACKGROUND_INFORMATION]
Options considered: [ALTERNATIVES]
Decision: [CHOSEN_SOLUTION]

Format as:
# ADR-[NUMBER]: [TITLE]

## Status
[Proposed/Accepted/Deprecated]

## Context
[Problem statement and constraints]

## Decision
[Chosen solution with rationale]

## Consequences
[Positive and negative outcomes]

## Alternatives Considered
[Other options and why they were rejected]

For this use case: [SPECIFIC_SCENARIO]

Recommend appropriate design patterns including:
1. Pattern name and description
2. Implementation approach
3. Benefits for this specific case
4. Potential drawbacks
5. Code structure example
6. Integration with existing architecture

Focus on patterns that enhance maintainability and scalability.