# Architecture Patterns > Architectural pattern guidance and layering principles. Use when architecture patterns guidance is required. - Skill: `majiayu000/architecture-patterns` (Agent Skill, multi-file: 2 files) - Install (CLI): `npx skillmds add majiayu000/architecture-patterns` - Raw SKILL.md: https://api.skillmd.com/api/skills/majiayu000/architecture-patterns/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Coding & Dev Tools - Author: majiayu000 (https://skillmd.com/u/majiayu000) - Updated: 2026-09-09 - Page: https://skillmd.com/skills/majiayu000/architecture-patterns --- # Core Architecture Patterns ## Layered Architecture Pattern ### Three-Tier Structure Implementation Apply layered architecture with strict separation of concerns: 1. Presentation Layer: User interface components 2. Business Logic Layer: Domain rules and operations 3. Data Access Layer: Database and external service interactions Enforce unidirectional dependencies: - Presentation Layer → Business Logic Layer - Business Logic Layer → Data Access Layer - Never allow reverse dependencies ### Domain Boundaries Enforcement Separate domain logic from infrastructure: - Keep business rules independent of frameworks - Use dependency injection for infrastructure concerns - Apply Domain-Driven Design principles - Define clear bounded contexts for complex domains Interface segregation requirements: - Create specific interfaces for different client needs - Avoid fat interfaces with multiple responsibilities - Use repository pattern for data access abstraction - Implement service interfaces for business operations ## Microservices Pattern Guidelines ### Service Decomposition Rules Apply single responsibility principle at service level: - Each service owns one business capability - Design services around business domains - Ensure loose coupling between services - Implement high cohesion within services Communication patterns enforcement: - Prefer synchronous communication for critical operations - Use asynchronous messaging for event-driven workflows - Implement circuit breakers for resilience - Apply API gateway pattern for external access ### Data Consistency Patterns Implement eventual consistency where appropriate: - Use saga pattern for distributed transactions - Apply event sourcing for audit trails - Implement CQRS for read/write separation - Ensure data ownership boundaries are clear ## Event-Driven Architecture Implementation ### Event Design Principles Design immutable, atomic events: - Each event represents a single business fact - Use past tense for event names (UserRegistered, OrderPlaced) - Include all required data in the event payload - Apply idempotency handling for duplicate events Event handling patterns: - Implement event handlers as pure functions - Use correlation IDs for request tracing - Apply dead letter queues for failed events - Monitor and log event processing metrics ### Message Broker Integration Configure reliable messaging infrastructure: - Set up topic/exchange hierarchies - Implement message versioning strategies - Configure appropriate quality of service levels - Apply backpressure handling for overload protection # Enterprise Integration Patterns ## API Design Standards ### RESTful API Implementation Follow REST architectural constraints: - Use appropriate HTTP methods (GET, POST, PUT, DELETE) - Implement proper status codes for all responses - Apply resource-based URL naming conventions - Use content negotiation for format handling API documentation requirements: - Generate OpenAPI/Swagger specifications - Include comprehensive request/response examples - Document error codes and handling procedures - Provide authentication and authorization details ### GraphQL Integration Patterns Schema-first development approach: - Define clear type system with strong typing - Implement proper resolver chains - Apply authorization at field level - Use data loaders to prevent N+1 queries Performance optimization techniques: - Implement query complexity analysis - Apply query depth limiting - Use persisted queries for frequently used operations - Monitor and log query performance metrics ## Security Architecture Patterns ### Zero Trust Security Model Implement defense-in-depth security: - Apply least privilege access control - Use mTLS for service-to-service communication - Implement JWT/OIDC for authentication - Apply API throttling and rate limiting Security monitoring and auditing: - Log all security-relevant events - Implement intrusion detection systems - Apply security information and event management (SIEM) - Conduct regular security assessments ### Secure API Gateway Configuration Apply API gateway security patterns: - Implement request/response transformation - Apply JSON Web Token validation - Use web application firewall (WAF) rules - Implement distributed tracing for security monitoring # Architecture Quality Attributes ## Scalability Patterns ### Horizontal Scaling Implementation Design for stateless services: - Externalize session state using distributed caches - Use database connection pooling efficiently - Implement auto-scaling policies based on metrics - Apply blue-green deployment strategies Performance optimization techniques: - Implement caching at multiple levels (CDN, application, database) - Use read replicas for database scaling - Apply asynchronous processing for non-critical operations - Implement sharding strategies for large datasets ### Resilience and Fault Tolerance Implement self-healing mechanisms: - Use health checks for service monitoring - Apply exponential backoff for retry logic - Implement circuit breakers to prevent cascading failures - Use chaos engineering for resilience testing Disaster recovery planning: - Implement multi-region deployment strategies - Use backup and restore procedures - Apply data replication across geographic locations - Document and test recovery procedures ## Maintainability and Evolution ### Technical Debt Management Apply architectural fitness functions: - Define measurable quality metrics - Implement automated architecture compliance checks - Use architectural decision records (ADRs) - Regularly review and refactor architectural decisions Evolutionary architecture principles: - Design for change with loose coupling - Use abstraction layers to isolate volatility - Implement feature flags for safe deployments - Apply strangler fig pattern for legacy system migration ### Documentation and Communication Maintain architectural documentation: - Create context diagrams for system overviews - Document data flows and integration points - Maintain architectural decision records - Provide deployment and runbooks Cross-functional collaboration: - Conduct regular architecture reviews - Use pair programming for critical components - Implement knowledge sharing practices - Provide training on architectural standards