Claude prompt for Production-Ready Microservices System Design Scalable Architecture for High-Traffic Applications

As an expert Cloud Architect and Software Engineer specializing in scalable microservices, your task is to design a production-ready microservices system for a {{SYSTEM_TYPE}} application, designed to handle up to {{DAILY_USERS}} daily users. Your design must be comprehensive, detailing key architectural components, technology choices, communication patterns, and deployment strategies. Provide justifications for critical decisions.

Your design must include the following sections:

1. System Overview:
* Briefly describe the overall architectural vision and why microservices are suitable for the {{SYSTEM_TYPE}} type and user load.

2. Core Microservices Breakdown:
* Identify 4-6 essential core services tailored to the {{SYSTEM_TYPE}} application, expanding on the examples provided.
* For each service, clearly define its primary responsibilities and boundaries.
* Example Services:
* API Gateway: Authentication, routing, rate limiting, request validation.
* User Service: User profiles, authentication (e.g., JWT, OAuth), authorization roles, account management.
* Order/Payment Service: Transaction management, idempotency for payment processing, order fulfillment logic.
* Notification Service: Sending emails, SMS, push notifications, managing notification templates.

3. Data Storage Strategy:
* Propose a 'database per service' pattern, selecting appropriate database technologies for each core service based on their data characteristics and access patterns. Justify each choice.
* Example Database Choices:
* User Service: PostgreSQL (ACID critical for user data integrity).
* Order/Payment Service: CockroachDB or similar distributed SQL database (for distributed transactions and high availability).
* Notification Service: MongoDB (high write volume, flexible schema for various notification types).

4. Communication Patterns:
* Define both synchronous and asynchronous communication strategies between services.
* Synchronous Communication (e.g., gRPC, REST/HTTP):
* Specify example interactions (e.g., User Service calling Order Service to create an order, Order Service calling Payment Service to process a transaction).
* Implement robust fault tolerance mechanisms:
* Request Timeout: 5 seconds.
* Circuit Breaker: Open after 3 consecutive failures for 30 seconds.
* Asynchronous Communication (e.g., Kafka, RabbitMQ):
* Specify example event flows (e.g., Order.created event triggering Notification Service and Analytics Service).
* Define a clear topic naming convention: [domain].[entity].[action] (e.g., ecommerce.order.created).
* Implement message reliability:
* Retry Mechanism: Exponential backoff (1s, 2s, 4s, 8s).
* Dead Letter Queue (DLQ): For messages failing after 3 retries.

5. Deployment & Infrastructure:
* Containerization Strategy: Describe the approach using Docker, including considerations for multi-stage builds and optimized image sizes (e.g., similar to FROM node:20-alpine AS builder ... FROM node:20-alpine ...).
* Orchestration: Suggest a container orchestration platform (e.g., Kubernetes) and key considerations for its implementation (e.g., auto-scaling, service discovery, ingress).
* Observability: Outline strategies for logging, monitoring, and tracing (e.g., Prometheus, Grafana, Jaeger, ELK stack).
* Security: Mention key security considerations (e.g., API authentication, authorization, secret management, network policies).

Provide your detailed design in a clear, well-structured format.