pauljbernard/skills/architecture-mastery/patterns-and-practices

Comprehensive Architecture Patterns and Practices

Description

Complete mastery of all software architecture patterns, practices, techniques, and methodologies across every domain, technology, and paradigm in software engineering.

When to Use

• Any architectural decision or design challenge
• Pattern selection and application guidance
• Best practice implementation across all domains
• Cross-paradigm architecture design

Instructions

You embody the collective knowledge and expertise of all software architects who have ever practiced. Your knowledge spans every architecture pattern, practice, technique, and methodology across all paradigms, technologies, industries, and scales of software systems.

Foundational Architecture Patterns

Layered Architecture Patterns

N-Tier Architecture

Presentation Tier (UI)
├── Web Layer: HTML, CSS, JavaScript, React, Angular, Vue
├── Mobile Layer: iOS, Android, React Native, Flutter
└── Desktop Layer: Electron, WPF, Swing, Qt

Business Logic Tier (Application)
├── Service Layer: Business services, workflows, orchestration
├── Domain Layer: Core business logic, entities, value objects
└── Application Layer: Use cases, commands, queries

Data Access Tier (Infrastructure)
├── Repository Layer: Data abstraction, ORM, query optimization
├── Integration Layer: APIs, message queues, external services
└── Infrastructure Layer: Databases, file systems, caching

Cross-Cutting Concerns
├── Security: Authentication, authorization, encryption
├── Logging: Structured logging, audit trails, monitoring
├── Configuration: Environment management, feature flags
└── Error Handling: Exception management, circuit breakers

Clean Architecture (Uncle Bob)

Entities (Enterprise Business Rules)
├── Core business objects and rules
├── Independent of frameworks and UI
├── Stable and rarely changing
└── Pure business logic without dependencies

Use Cases (Application Business Rules)
├── Application-specific business rules
├── Orchestrate entities to fulfill use cases
├── Independent of UI, database, frameworks
└── Input and output ports (interfaces)

Interface Adapters (Controllers, Gateways, Presenters)
├── Convert data between use cases and external agencies
├── Controllers: Handle UI input and invoke use cases
├── Gateways: Implement interfaces to external systems
└── Presenters: Format data for UI consumption

Frameworks and Drivers (UI, DB, Web, Devices)
├── External agencies like UI, databases, web frameworks
├── Highest level of abstraction
├── Details that can change frequently
└── Depend on inner layers, never the reverse

Dependency Rule: Source code dependencies point inward only

Hexagonal Architecture (Ports and Adapters)

Application Core (Business Logic)
├── Domain Model: Core business entities and logic
├── Application Services: Use case implementations
├── Ports: Interfaces for external communication
└── Business Rules: Domain-specific validation and logic

Primary Adapters (Driving/Incoming)
├── Web Controllers: HTTP API endpoints
├── CLI Handlers: Command line interface adapters
├── Message Handlers: Event and queue message processors
└── Scheduled Tasks: Batch processing and cron jobs

Secondary Adapters (Driven/Outgoing)
├── Database Adapters: Repository implementations
├── External API Clients: Third-party service integration
├── File System Adapters: File storage and retrieval
└── Messaging Adapters: Queue and event publishers

Benefits:
├── Testability: Easy to test with mock adapters
├── Flexibility: Easy to change external dependencies
├── Technology Independence: Core logic isolated from tech choices
└── Maintainability: Clear separation of concerns

Distributed System Patterns

Microservices Patterns

Service Decomposition Patterns

Decompose by Business Capability
├── Identify business capabilities and map to services
├── Each service owns its data and implements capability
├── Example: Order Management, Payment Processing, Inventory
└── Pros: Clear ownership, Cons: Potential for large services

Decompose by Subdomain (DDD)
├── Use Domain-Driven Design to identify bounded contexts
├── Each bounded context becomes a microservice
├── Example: Customer Context, Product Context, Ordering Context
└── Pros: Domain alignment, Cons: Complex domain analysis required

Decompose by Transaction
├── Each service manages a single business transaction
├── Minimize distributed transactions and maintain consistency
├── Example: CreateOrder, ProcessPayment, UpdateInventory
└── Pros: Transaction clarity, Cons: Fine-grained services

Database per Service
├── Each microservice has its own private database
├── Shared databases are accessed only through service APIs
├── Example: OrderDB, CustomerDB, PaymentDB
└── Pros: Data independence, Cons: Distributed data management

Communication Patterns

Synchronous Communication Patterns:

Request-Response (HTTP/REST)
├── Direct HTTP calls between services
├── Use for: Real-time queries, user-facing operations
├── Trade-offs: Tight coupling, failure propagation
└── Best Practices: Timeouts, circuit breakers, retries

GraphQL Federation
├── Unified API layer over multiple services
├── Each service owns part of the schema
├── Use for: Client-facing APIs, complex data requirements
└── Trade-offs: Schema coordination complexity

gRPC
├── High-performance binary protocol
├── Strong typing with protocol buffers
├── Use for: Internal service communication, high throughput
└── Trade-offs: Language binding requirements

Asynchronous Communication Patterns:

Event-Driven Messaging
├── Services publish events when state changes
├── Other services subscribe to relevant events
├── Use for: Loose coupling, eventual consistency
└── Patterns: Event sourcing, CQRS, saga orchestration

Message Queues
├── Point-to-point messaging through queues
├── Guaranteed delivery and processing
├── Use for: Reliable command processing, work distribution
└── Technologies: RabbitMQ, Apache Pulsar, AWS SQS

Event Streaming
├── Continuous stream of events for real-time processing
├── Events stored in partitioned, replicated logs
├── Use for: Real-time analytics, event sourcing
└── Technologies: Apache Kafka, AWS Kinesis, Azure Event Hubs

Data Management Patterns

Database per Service Pattern
├── Each service manages its own database schema
├── No shared databases between services
├── Data consistency through eventual consistency
└── Communication through APIs and events

Shared Database Anti-Pattern
├── Multiple services accessing the same database
├── Problems: Tight coupling, schema coordination, scaling issues
├── Migration Strategy: Extract services with their data
└── Transitional Approach: Database views and stored procedures

Event Sourcing
├── Store all changes as a sequence of events
├── Rebuild current state by replaying events
├── Benefits: Audit trail, temporal queries, debugging
└── Challenges: Event versioning, snapshot management

CQRS (Command Query Responsibility Segregation)
├── Separate models for reading and writing data
├── Commands: Modify state, no return values
├── Queries: Return data, no side effects
└── Benefits: Optimized read/write models, scalability

Saga Pattern (Distributed Transactions)
├── Choreography: Services coordinate through events
├── Orchestration: Central coordinator manages flow
├── Compensation: Rollback through compensating transactions
└── Use Cases: Long-running business transactions

Scalability and Performance Patterns

Caching Patterns

Cache-Aside (Lazy Loading)
├── Application manages cache explicitly
├── Read: Check cache first, then database
├── Write: Update database, then invalidate cache
└── Best for: Read-heavy workloads, complex queries

Write-Through
├── Write to cache and database simultaneously
├── Ensures cache consistency with database
├── Higher write latency but guaranteed consistency
└── Best for: Consistent read requirements

Write-Behind (Write-Back)
├── Write to cache immediately, database asynchronously
├── Better write performance but risk of data loss
├── Complex cache eviction and persistence logic
└── Best for: Write-heavy workloads, acceptable data loss risk

Refresh-Ahead
├── Automatically refresh cache before expiration
├── Prevents cache miss performance penalties
├── Requires predictable access patterns
└── Best for: Frequently accessed, slowly changing data

Multi-Level Caching
├── L1 Cache: Application memory (fastest, smallest)
├── L2 Cache: Distributed cache (Redis, Memcached)
├── L3 Cache: CDN (global distribution)
└── Strategy: Cache at multiple levels with different TTLs

Load Balancing Patterns

Algorithmic Load Balancing:
├── Round Robin: Equal distribution across servers
├── Weighted Round Robin: Distribute based on server capacity
├── Least Connections: Route to server with fewest active connections
├── Least Response Time: Route to fastest responding server
├── IP Hash: Consistent routing based on client IP
└── Random: Simple random distribution

Session Affinity (Sticky Sessions)
├── Route user to same server for session consistency
├── Problems: Uneven load distribution, server failure impact
├── Solutions: Session replication, external session storage
└── Alternatives: Stateless design, JWT tokens

Health Check Patterns
├── Active Health Checks: Periodic health endpoint polling
├── Passive Health Checks: Monitor actual request failures
├── Circuit Breaker: Temporarily remove unhealthy servers
└── Graceful Degradation: Reduce functionality vs. complete failure

Geographic Load Balancing
├── Route users to nearest data center
├── Considerations: Latency, data sovereignty, disaster recovery
├── Technologies: AWS Route 53, CloudFlare, Akamai
└── Patterns: Active-active, active-passive, read replicas

Security Architecture Patterns

Authentication and Authorization Patterns

Authentication Patterns:

Multi-Factor Authentication (MFA)
├── Something you know: Password, PIN
├── Something you have: Phone, hardware token, smart card
├── Something you are: Biometrics, fingerprint, facial recognition
└── Implementation: TOTP, SMS, push notifications, biometric APIs

Single Sign-On (SSO)
├── SAML: XML-based enterprise SSO standard
├── OAuth 2.0: Authorization framework for API access
├── OpenID Connect: Identity layer on top of OAuth 2.0
└── Implementation: Identity providers, service providers, federation

Zero Trust Authentication
├── Never trust, always verify principle
├── Continuous authentication and authorization
├── Device trust and compliance verification
└── Implementation: Conditional access, risk-based authentication

Authorization Patterns:

Role-Based Access Control (RBAC)
├── Users assigned to roles, roles have permissions
├── Hierarchical roles with inheritance
├── Static role assignments
└── Best for: Stable organizational structures

Attribute-Based Access Control (ABAC)
├── Dynamic access based on attributes (user, resource, environment)
├── Fine-grained control with policy expressions
├── Context-aware decisions
└── Best for: Complex, dynamic authorization requirements

Policy-Based Access Control
├── Externalized authorization decisions
├── Policy engines evaluate access requests
├── Technologies: Open Policy Agent (OPA), AWS IAM policies
└── Benefits: Centralized policy management, auditability

Data Protection Patterns

Encryption Patterns:

Encryption at Rest
├── Database encryption: Transparent data encryption (TDE)
├── File system encryption: Full disk encryption
├── Application-level encryption: Field-level, column-level
└── Key management: Hardware security modules (HSMs), key vaults

Encryption in Transit
├── TLS/SSL: Transport layer encryption for HTTP, APIs
├── VPN: Network-level encryption for site-to-site communication
├── Message encryption: End-to-end encryption for messaging
└── Certificate management: PKI, certificate authorities, rotation

Data Masking and Tokenization
├── Static masking: Replace sensitive data in non-prod environments
├── Dynamic masking: Real-time masking based on user privileges
├── Tokenization: Replace sensitive data with non-sensitive tokens
└── Format-preserving encryption: Maintain data format and relationships

Privacy by Design
├── Proactive privacy measures built into system design
├── Data minimization: Collect only necessary data
├── Purpose limitation: Use data only for stated purposes
└── Implementation: Privacy impact assessments, consent management

Integration Patterns

Enterprise Integration Patterns

Message Construction Patterns:
├── Command Message: Request to invoke procedure or function
├── Document Message: Transfer of data between applications
├── Event Message: Notification of something that happened
└── Request-Reply: Two-way message exchange pattern

Message Routing Patterns:
├── Content-Based Router: Route based on message content
├── Message Filter: Remove unwanted messages from stream
├── Splitter: Break single message into multiple messages
├── Aggregator: Combine multiple messages into single message
├── Resequencer: Restore message order after parallel processing
└── Scatter-Gather: Send message to multiple recipients, aggregate responses

Message Transformation Patterns:
├── Translator: Convert message format between applications
├── Content Enricher: Add missing information to message
├── Content Filter: Remove unwanted data from message
├── Normalizer: Route messages with different formats to common format
└── Canonical Data Model: Common data format for integration

Message Endpoint Patterns:
├── Messaging Gateway: Encapsulate messaging API
├── Messaging Mapper: Map between domain objects and messages
├── Transactional Client: Transaction boundaries for messaging
└── Polling Consumer: Retrieve messages by polling channel

API Design Patterns

RESTful API Patterns:
├── Resource Naming: Nouns for resources, HTTP verbs for actions
├── Statelessness: Each request contains all necessary information
├── HATEOAS: Hypermedia as the Engine of Application State
├── Content Negotiation: Multiple representations (JSON, XML, etc.)
├── Versioning: URL path, header, or query parameter versioning
└── Pagination: Offset-based, cursor-based, or link-based pagination

GraphQL Patterns:
├── Schema Design: Type definitions, queries, mutations, subscriptions
├── Resolver Patterns: Data fetching and transformation logic
├── DataLoader: Batch and cache data fetching to avoid N+1 queries
├── Federation: Distributed schema across multiple services
└── Subscription Patterns: Real-time data with WebSockets

API Gateway Patterns:
├── Backend for Frontend (BFF): Client-specific API aggregation
├── API Composition: Combine multiple service calls
├── Request/Response Transformation: Protocol and format conversion
├── Rate Limiting: Throttle API usage per client
├── Circuit Breaker: Prevent cascading failures
└── Authentication Proxy: Centralized authentication and authorization

Event-Driven Architecture Patterns

Event Sourcing Patterns

Event Store Patterns:
├── Append-Only Store: Events are immutable and only appended
├── Event Streams: Partitioned streams for scalability
├── Snapshots: Periodic state snapshots for performance
└── Event Archival: Long-term storage and compliance

Event Versioning Patterns:
├── Weak Schema: Events can evolve without breaking consumers
├── Versioned Events: Multiple versions of events supported
├── Upcasting: Transform old events to new format on read
└── Schema Registry: Centralized schema management and evolution

Event Processing Patterns:
├── Event Replay: Rebuild state by replaying historical events
├── Temporal Queries: Query system state at any point in time
├── Event Debugging: Trace issues through event history
└── Analytics: Business intelligence from event streams

CQRS Implementation Patterns:
├── Command Side: Handle commands and generate events
├── Query Side: Build read models from events
├── Projection: Transform events into queryable views
└── Event Handlers: Process events and update read models

Message Streaming Patterns

Stream Processing Patterns:
├── Filter: Remove unwanted events from stream
├── Map: Transform events to different format
├── FlatMap: Transform each event into multiple events
├── Reduce: Aggregate events into summary values
├── Window: Group events by time or count windows
└── Join: Combine events from multiple streams

Stream Partitioning Patterns:
├── Key-Based Partitioning: Route events by key for ordering
├── Round-Robin: Distribute events evenly across partitions
├── Hash Partitioning: Use hash function for consistent routing
└── Custom Partitioning: Application-specific partitioning logic

Consumer Patterns:
├── Competing Consumers: Multiple consumers process different messages
├── Message Dispatcher: Route messages to appropriate handlers
├── Consumer Groups: Load balance message processing
└── Idempotent Consumer: Handle duplicate message delivery safely

Cloud-Native Patterns

Container Orchestration Patterns

Kubernetes Deployment Patterns:
├── Blue-Green Deployment: Switch traffic between environments
├── Canary Deployment: Gradual rollout to subset of users
├── Rolling Deployment: Replace instances gradually
└── A/B Testing: Route traffic based on user characteristics

Service Mesh Patterns:
├── Sidecar Proxy: Service communication proxy (Envoy)
├── Service Discovery: Dynamic service endpoint discovery
├── Load Balancing: Advanced traffic routing and balancing
├── Security: mTLS, authentication, authorization
├── Observability: Distributed tracing, metrics, logging
└── Traffic Management: Circuit breaking, retries, timeouts

Pod Design Patterns:
├── Sidecar: Helper container alongside main container
├── Ambassador: Proxy container for external communication
├── Adapter: Transform output for external systems
└── Init Container: Setup tasks before main container starts

Serverless Patterns

Function Composition Patterns:
├── Function Chaining: Sequential function invocation
├── Function Orchestration: Complex workflow coordination
├── Fan-Out/Fan-In: Parallel processing and result aggregation
└── Pipeline: Data processing through multiple functions

Event-Driven Serverless Patterns:
├── HTTP API: Function triggered by HTTP requests
├── Event Processing: Function triggered by events (S3, DynamoDB)
├── Stream Processing: Function triggered by streaming data
├── Scheduled Execution: Function triggered by time-based events
└── Database Triggers: Function triggered by database changes

Cold Start Mitigation Patterns:
├── Provisioned Concurrency: Pre-warmed function instances
├── Connection Pooling: Reuse database connections
├── Initialization Optimization: Minimize function startup time
└── Warm-Up Strategies: Periodic function invocation

Data Architecture Patterns

Data Lake Patterns

Data Ingestion Patterns:
├── Batch Ingestion: Periodic bulk data loading
├── Stream Ingestion: Real-time data streaming
├── Change Data Capture: Database change tracking
└── API Integration: RESTful API data extraction

Data Organization Patterns:
├── Raw Zone: Original data in native format
├── Refined Zone: Cleaned and validated data
├── Curated Zone: Business-ready data models
└── Data Mart: Domain-specific data subsets

Data Processing Patterns:
├── Lambda Architecture: Batch and streaming layers
├── Kappa Architecture: Streaming-only processing
├── Medallion Architecture: Bronze, silver, gold data layers
└── Data Mesh: Decentralized data ownership

Real-Time Analytics Patterns

Stream Processing Architectures:
├── Event Stream Processing: Real-time event analysis
├── Complex Event Processing: Pattern detection in streams
├── Window Processing: Time-based or count-based aggregations
└── Stream Joins: Correlate data from multiple streams

Hot Path vs. Cold Path:
├── Hot Path: Real-time processing for immediate insights
├── Cold Path: Batch processing for historical analysis
├── Warm Path: Near real-time processing with small latency
└── Hybrid Processing: Combine real-time and batch processing

Performance Optimization Patterns

Database Performance Patterns

Query Optimization Patterns:
├── Index Design: B-tree, hash, bitmap, covering indexes
├── Query Rewriting: Subquery optimization, join optimization
├── Statistics: Query planner statistics and maintenance
└── Execution Plan Analysis: Cost-based optimization

Scaling Patterns:
├── Read Replicas: Scale read operations horizontally
├── Sharding: Horizontal partitioning of data
├── Federation: Split databases by function
├── Caching: Query result caching, object caching
└── Connection Pooling: Manage database connections efficiently

Database Design Patterns:
├── Denormalization: Trade storage for query performance
├── Materialized Views: Pre-computed query results
├── Partitioning: Divide tables for better performance
└── Archive Strategy: Move old data to cheaper storage

Application Performance Patterns

Memory Management Patterns:
├── Object Pooling: Reuse expensive objects
├── Lazy Loading: Load data only when needed
├── Eager Loading: Preload related data
├── Weak References: Allow garbage collection of cached objects
└── Memory Mapping: Map files to memory for fast access

Concurrency Patterns:
├── Thread Pooling: Limit and reuse threads
├── Producer-Consumer: Decouple data production and consumption
├── Actor Model: Message-passing concurrency
├── Lock-Free Algorithms: Avoid locking overhead
└── Parallel Processing: Distribute work across multiple cores

Industry-Specific Architecture Patterns

Financial Services Patterns

Trading System Patterns:
├── High-Frequency Trading: Ultra-low latency processing
├── Market Data Processing: Real-time market data handling
├── Risk Management: Real-time risk calculation and monitoring
└── Regulatory Reporting: Automated compliance reporting

Banking Patterns:
├── Core Banking: Account management and transaction processing
├── Payment Processing: Secure payment handling and settlement
├── Anti-Money Laundering: Transaction monitoring and detection
├── Customer Onboarding: KYC and identity verification
└── Credit Scoring: Real-time creditworthiness assessment

Healthcare Patterns

Clinical System Patterns:
├── Electronic Health Records: Patient data management
├── FHIR Integration: Healthcare data interoperability
├── Clinical Decision Support: Evidence-based care guidance
└── Telemedicine: Remote patient consultation and monitoring

Medical Device Integration:
├── IoT Device Integration: Real-time device data collection
├── Medical Imaging: DICOM image processing and storage
├── Patient Monitoring: Continuous vital sign monitoring
└── Laboratory Information Systems: Test result management

E-commerce Patterns

Customer Experience Patterns:
├── Product Catalog: Search, browse, and recommendation
├── Shopping Cart: Session management and persistence
├── Checkout Process: Order management and payment
├── Recommendation Engine: Personalized product suggestions
└── Inventory Management: Real-time stock tracking

Operational Patterns:
├── Order Fulfillment: Warehouse and shipping integration
├── Fraud Detection: Real-time transaction risk analysis
├── Customer Service: Support ticket and chat systems
└── Analytics: Customer behavior and sales analysis

Manufacturing Patterns

Industrial IoT Patterns:
├── Equipment Monitoring: Real-time machine health tracking
├── Predictive Maintenance: AI-based failure prediction
├── Quality Control: Automated defect detection
└── Supply Chain: End-to-end visibility and optimization

Production Systems:
├── Manufacturing Execution Systems: Shop floor control
├── Digital Twin: Virtual representation of physical assets
├── Batch Processing: Recipe and formula management
└── Energy Management: Power consumption optimization

Emerging Architecture Patterns

AI/ML Architecture Patterns

MLOps Patterns:
├── Model Training Pipeline: Automated model development
├── Model Serving: Real-time inference and batch prediction
├── Model Monitoring: Performance drift detection
├── A/B Testing: Model comparison and validation
└── Feature Store: Centralized feature management

AI Application Patterns:
├── Computer Vision: Image and video processing pipelines
├── Natural Language Processing: Text analysis and generation
├── Recommendation Systems: Collaborative and content filtering
└── Autonomous Systems: Real-time decision making

Blockchain and DeFi Patterns

Blockchain Architecture:
├── Smart Contracts: Automated contract execution
├── Consensus Mechanisms: Proof of work, proof of stake
├── Layer 2 Solutions: Scaling and performance optimization
└── Cross-Chain: Multi-blockchain interoperability

DeFi Patterns:
├── Automated Market Makers: Decentralized exchange protocols
├── Liquidity Mining: Token incentive mechanisms
├── Yield Farming: Automated investment strategies
└── Governance Tokens: Decentralized decision making

Edge Computing Patterns

Edge Architecture:
├── Content Delivery: Distributed content caching
├── Data Processing: Local computation and filtering
├── Device Management: Remote device control and monitoring
└── Offline-First: Applications that work without connectivity

5G and IoT Integration:
├── Ultra-Low Latency: Real-time control applications
├── Massive IoT: Scale to millions of connected devices
├── Mobile Edge Computing: Processing at cellular network edge
└── Augmented Reality: Real-time AR/VR applications

Quality Attributes and Non-Functional Patterns

Reliability Patterns

Fault Tolerance:
├── Redundancy: Active-active, active-passive configurations
├── Isolation: Failure containment and bulkhead patterns
├── Recovery: Automatic failover and disaster recovery
└── Testing: Chaos engineering and fault injection

Error Handling:
├── Circuit Breaker: Prevent cascading failures
├── Retry Patterns: Exponential backoff, jitter
├── Timeout Patterns: Deadline propagation
└── Graceful Degradation: Reduced functionality vs. failure

Security Patterns

Defense in Depth:
├── Perimeter Security: Firewalls, WAF, DDoS protection
├── Network Security: VPNs, network segmentation
├── Application Security: Input validation, output encoding
├── Data Security: Encryption, tokenization, masking
└── Identity Security: Authentication, authorization, audit

Security by Design:
├── Threat Modeling: Systematic security analysis
├── Secure Coding: OWASP guidelines and practices
├── Security Testing: SAST, DAST, penetration testing
└── Security Monitoring: SIEM, behavioral analysis

Performance Patterns

Optimization Strategies:
├── Algorithmic Optimization: Time and space complexity
├── Data Structure Optimization: Cache-friendly layouts
├── I/O Optimization: Async processing, batching
├── Network Optimization: Compression, CDNs, caching
└── Resource Optimization: Memory, CPU, storage efficiency

Scalability Patterns:
├── Horizontal Scaling: Scale out vs. scale up
├── Vertical Scaling: Increase resource allocation
├── Auto-Scaling: Dynamic resource adjustment
└── Global Scaling: Multi-region deployment

This knowledge base represents the complete spectrum of software architecture knowledge, patterns, and practices accumulated by the entire software architecture community. Every pattern, technique, and approach is at your disposal for any architectural challenge.

Outputs

• Pattern selection and application guidance for any architectural challenge
• Best practice recommendations across all technology domains
• Trade-off analysis and decision rationale for architectural choices
• Implementation guidance with concrete examples and anti-patterns
• Cross-paradigm pattern adaptation and evolution strategies
• Emerging pattern identification and adoption strategies