Scalable System Architecture Design prompt for developers

As a Senior Software Architect, design a highly scalable, fault-tolerant, and performant system for the given use case and requirements.

Use Case: {USE_CASE_DESCRIPTION}

Functional Requirements:
- {KEY_FEATURES_COMMA_SEPARATED}

Non-Functional Requirements:
- Scalability: Must support horizontal scaling to handle peak loads.
- Fault Tolerance: System must remain operational despite component failures.
- Latency: API response times under {LATENCY_MS} ms for critical operations.
- High Availability: {AVAILABILITY_PERCENTAGE}% uptime.
- Security: Implement industry-standard security practices (e.g., authentication, authorization, data encryption).
- Maintainability: Codebase should be modular and easy to maintain.
- Cost-Effectiveness: Design should consider operational costs.

Expected Load:
- Concurrent Users: {CONCURRENT_USERS}
- Requests per Second (Peak): {RPS_PEAK}

Deliverables (Structured Response):

1. High-Level Architecture Overview:
* Identify core components (e.g., API Gateway, Load Balancer, Services, Databases, Caches, Message Queues).
* Illustrate data flow and interactions between components.
* Describe the rationale behind component choices.

2. Technology Stack Justification:
* Propose specific technologies for each major component (e.g., programming languages, frameworks, databases, cloud providers, messaging systems).
* Justify each choice based on non-functional requirements and architectural principles.

3. High-Level Database Schema Design:
* Outline key entities, their attributes, and relationships.
* Specify database type(s) (e.g., SQL, NoSQL, graph) and rationale.
* Consider data partitioning and indexing strategies.

4. API Design (RESTful/GraphQL):
* Define key API endpoints (e.g., GET /resource, POST /resource, PUT /resource/{id}).
* Specify HTTP methods, high-level request/response structures, and error handling.
* Indicate whether RESTful or GraphQL is more appropriate and why.

5. Scaling Strategy:
* Detailed plan for horizontal and/or vertical scaling of each component.
* Caching strategies (e.g., CDN, distributed cache, in-memory) and invalidation.
* Message queuing/streaming for asynchronous processing and decoupling.
* Load balancing mechanisms.
* Sharding or partitioning strategies for data layers.

6. Monitoring, Logging, and Alerting:
* Propose tools and strategies for observing system health, performance, and errors.
* Define key metrics to monitor.
* Outline alerting mechanisms.

7. Deployment Strategy:
* Suggest a deployment model (e.g., containerization with Kubernetes, serverless functions).
* Briefly describe CI/CD pipeline considerations.

8. Trade-offs, Risks, and Mitigation:
* Identify major architectural trade-offs made (e.g., consistency vs. availability, cost vs. performance).
* Enumerate potential risks (e.g., vendor lock-in, data consistency issues, security vulnerabilities).
* Propose mitigation strategies for identified risks.

Ensure the response is detailed yet concise, focusing on clarity and architectural soundness.