12 Claude Prompts for Architecture ADRs & RFCs

Act as a Principal Software Architect. I need to document a critical engineering decision using Michael Nygard's standard ADR format. Context & Decision Inputs: - System Domain: [Insert domain, e.g., FinTech core payment engine] - Current Problem: [Insert current issue, e.g., Database connection pool saturation under peak load] - Proposed Decision: [Insert decision, e.g., Migrating from self-managed PostgreSQL to Amazon Aurora PostgreSQL Serverless v2] - Alternatives Considered: [Insert alternative 1, alternative 2] Please generate a complete, production-grade Architecture Decision Record containing: 1. Title: Short, numbered, and imperative (e.g., 'ADR 004: Adopt Amazon Aurora Serverless v2 for Payment Ledger') 2. Status: Proposed / Accepted / Superseded 3. Context: Deep technical dive into technical drivers, constraints, SLAs, throughput requirements, and developer velocity impacts. 4. Decision: Precise architectural choice with structural diagrams described in ASCII or Mermaid format. 5. Consequences: Detailed breakdown of Positive Outcomes, Negative Trade-offs, Operational Risks, and Mitigation Strategies. 6. Compliance & Security Implications: Data-at-rest encryption, PII handling, and audit logging adjustments.

You are a Staff Enterprise Architect specializing in distributed systems. I need a comprehensive Request for Comments (RFC) document to decompose a legacy monolithic service into independent microservices. Project Scope: - Monolith Component: [e.g., Order Processing and Inventory Monolith] - Target Microservices: [e.g., Order Management Service, Inventory Reservation Service, Fulfillment Engine] - Communication Pattern: [e.g., Asynchronous Event-Driven via Apache Kafka with outbox pattern] - Target SLA / SLO: [e.g., 99.99% availability, p99 latency < 120ms] Draft a multi-page RFC including: 1. Executive Summary & Problem Statement 2. Bounded Context & Domain-Driven Design (DDD) Entity Mapping 3. Database-per-service Migration Strategy (Handling shared tables, foreign keys, dual-write phase, and zero-downtime data migration) 4. Distributed Transaction Strategy (Saga Pattern vs 2-Phase Commit) 5. Network Topology, Service Discovery, and API Gateway Routing 6. Observability Plan (Distributed tracing via OpenTelemetry, metrics, logs aggregation) 7. Rollback Strategy & Phased Traffic Cutover Plan (Canary deployment stages).

Act as a Database Engineering Architect. Generate an objective, rigorous Architecture Decision Record comparing database technology migration options. Current Stack: [e.g., Single MySQL 8.0 Primary with read replicas] Pain Points: [e.g., Table write locks on 800M+ rows, complex sharding overhead, cross-region replication lag] Target Contenders: [e.g., CockroachDB, AWS Aurora Global Database, ScyllaDB] Workload Profile: [e.g., 70% Writes / 30% Reads, ACID compliance required, multi-region active-active] Structure the ADR with: - Comprehensive comparative matrix covering ACID compliance, write latency, horizontal scalability, operational complexity, cloud vendor lock-in, and TCO (Total Cost of Ownership). - Specific architectural benchmarks required before final sign-off. - Schema migration and backfill strategy. - Fallback plan if replication latency exceeds critical thresholds.

Act as an API Platform Architect. Draft a comprehensive RFC defining the organizational standard for internal service-to-service communication. Requirements Context: - Primary Candidates: RESTful JSON over HTTP/2, gRPC with Protocol Buffers, and GraphQL. - Workload Characteristics: [e.g., High-throughput real-time microservices with polyglot tech stack (Go, TypeScript, Python)] - Security Requirements: [e.g., Mutual TLS (mTLS), SPIFFE/SPIRE identity management] RFC Deliverables: 1. Problem Definition & Evaluation Criteria (Throughput, serialization overhead, schema evolution, developer tooling, debugging ease). 2. Recommended Protocol Matrix by Use Case (Public Gateway vs East-West Service Mesh). 3. Protobuf / Schema Repository Governance (Versioning rules, breaking change policies, automated linting via CI/CD). 4. Client SDK Generation and Maintenance Strategy. 5. Performance benchmarks summary and load testing guidelines.

You are a Cloud Infrastructure Architect. Draft a detailed RFC introducing an enterprise-grade Event-Driven Architecture (EDA). Parameters: - Core Message Broker: [e.g., Apache Kafka / AWS Kinesis / RabbitMQ] - Use Cases: [e.g., Asynchronous notifications, event sourcing for audit trails, materialized view hydration] - Message Volume: [e.g., 50,000 events/sec peak, payload size ~15KB] Draft the RFC with deep technical sections: 1. Architecture Overview (Event Producers, Topics, Partitioning Keys, Consumer Groups). 2. Message Delivery Guarantees (At-least-once vs Exactly-once semantics via idempotent consumers). 3. Dead Letter Queue (DLQ) Strategy, Poison Pill Handling, and Automated Re-drive Mechanisms. 4. Schema Registry and Schema Evolution Policies (Backward/Forward compatibility). 5. Monitoring & Alerting (Consumer group lag thresholds, under-replicated partitions).

Act as an Enterprise Migration Specialist. Write an ADR establishing the Strangler Fig migration pattern to incrementally decommission a critical legacy software system. Legacy System: [e.g., Ruby on Rails 4.2 monolithic eCommerce core] Target Platform: [e.g., Next.js Frontend + Go microservices hosted on AWS EKS] Traffic: [e.g., 5M monthly active users, $20M monthly transaction volume] Include in the ADR: - Architectural Decision on proxy routing layer (e.g., Cloudflare Workers / Envoy Gateway) to split traffic dynamically. - Step-by-step migration stages: Intercept -> Coexist -> Deprecate. - Data synchronization protocol between legacy database and new microservice databases. - Failure modes analysis: What happens when the new service degrades? (Automatic failback to legacy path). - Success metrics to mark the legacy subsystem ready for termination.

Act as a Principal Security Architect. Produce a detailed technical RFC proposing a unified Zero-Trust IAM & Authorization framework across all backend services. System Baseline: - Target Stack: [e.g., Kubernetes multi-tenant clusters across GCP and AWS] - Protocols: [e.g., OAuth 2.1, OpenID Connect (OIDC), OPA (Open Policy Agent) / Cedar engine] - Identity Provider: [e.g., Okta / Keycloak / Auth0] Create an RFC covering: 1. AuthN vs AuthZ boundary definitions. 2. Machine-to-Machine (M2M) authentication using mTLS and short-lived JWTs. 3. Fine-Grained Authorization (FGA) / Policy-as-Code implementation via OPA sidecars. 4. Token lifecycle, refresh flows, cryptographic key rotation, and instant revocation mechanisms. 5. Threat Model Analysis (OWASP API Top 10 vulnerabilities mitigation matrix). 6. Developer guide for integrating security middleware into existing microservices.

You are a Site Reliability & Disaster Recovery Architect. Generate a formal ADR establishing our cross-region Disaster Recovery strategy. Operational Constraints: - Target RTO (Recovery Time Objective): [e.g., < 15 minutes] - Target RPO (Recovery Point Objective): [e.g., < 1 minute (near-zero data loss)] - Deployment Model: [e.g., Active-Passive warm standby vs Active-Active multi-region] - Primary Region: [e.g., us-east-1] | DR Region: [e.g., us-west-2] Provide the ADR containing: - Detailed justification for selected multi-region strategy based on cost vs downtime business impact. - DNS Failover Mechanics (Route53 health checks, routing policies, automated vs manual promotion trigger). - State replication architecture (Database global replication, S3 cross-region replication, Secrets synchronization). - Chaos Engineering and Disaster Recovery Testing Cadence. - Cost estimation and infrastructure overhead breakdown.

Act as a High-Performance Systems Architect. Write an RFC detailing a robust multi-tier caching architecture to reduce database read bottlenecks. Context: - Application: [e.g., Social media feed and real-time user profiles] - Caching Layer: [e.g., In-memory local cache + Redis Cluster 7.x] - Key Metrics: [e.g., 95% Cache Hit Ratio target, sub-5ms read latency] Draft the RFC with: 1. Caching Topology: Multi-tier breakdown (L1 application memory + L2 distributed Redis). 2. Cache Eviction & Invalidation Patterns (Cache-Aside, Write-Through, Write-Behind, Time-to-Live strategies). 3. Mitigation strategies for common cache failures: Thundering Herd problem, Cache Stampede, Cache Penetration, and Cache Avalanche. 4. Redis Cluster sizing, partition sharding, memory fragmentation management, and high availability configuration. 5. Cache telemetry metrics and dynamic invalidation hook implementations.

Act as a Lead Backend Architect. Create an ADR addressing the migration of heavy computation tasks from synchronous HTTP lifecycles to background job queues. Workload Scenario: - Target Process: [e.g., PDF financial report compilation and AI embeddings generation] - Issue: [e.g., HTTP 504 Gateway Timeouts, web server worker starvation under spike loads] - Selected Technology: [e.g., Temporal.io workflow engine / Celery with Redis / AWS SQS + Lambda] Generate the ADR with: - Context and operational limits of the current synchronous request-response flow. - Architectural paradigm comparison: Polling vs Webhooks vs WebSockets for notifying clients upon job completion. - Resiliency model: Exponential backoff retries, idempotent execution keys, and workflow state persistence. - Infrastructure sizing, autoscaling triggers, and resource isolation. - Complete rollback parameters and developer ergonomics impact.

You are an Enterprise Integration Architect. Draft a technical RFC to build an isolated Third-Party Vendor Integration Gateway. Use Case: - External Integrations: [e.g., Stripe, Twilio, Plaid, Salesforce CRM APIs] - Risks: [e.g., External API latency spikes, vendor outages, rate limiting, silent payload schema changes] Draft an RFC detailing: 1. Dedicated Integration Gateway architecture (Circuit breaker pattern via Resilience4j/Envoy). 2. Rate limiting and request throttling policies (Token bucket / Leaky bucket per vendor quota). 3. Webhook handling infrastructure (Signature verification, raw payload persistence for auditability, replay protection). 4. Mock testing harness and contract testing (Pact / Prism) for automated CI/CD testing. 5. PII sanitization and egress proxy logging compliance.

Act as a Chief Architect. Write an ADR that formally supersedes and deprecates a previous architectural decision that failed to deliver expected outcomes. Deprecated Decision: [e.g., ADR 012: Adoption of GraphQL Federation for Microservices] New Replacement Decision: [e.g., ADR 028: Migration to Lightweight Backend-for-Frontend (BFF) Pattern using REST/JSON] Reasons for Failure: [e.g., High cognitive complexity, N+1 query bottlenecks across subgraphs, lack of client-side schema ownership] Draft the ADR with: - Detailed root cause analysis on why the previous architecture underperformed. - Direct comparison of superseded vs replacement architecture. - Safe transition and sunsetting timeline for deprecating legacy federation endpoints. - Architectural lessons learned to prevent future misalignments. - Updated operational runbooks and team ownership matrix.