Messaging, data management, and implementation patterns.
Messaging patterns enable asynchronous communication between distributed system components through intermediaries like message brokers and event buses. Instead
The async request-reply pattern decouples long-running backend operations from frontend clients by returning an immediate acknowledgment with a correlation ID,
The Claim Check pattern separates large message payloads from message metadata by storing the payload in external storage (S3, blob storage) and passing only a
Choreography is a distributed coordination pattern where services communicate through events without a central controller. Each service listens for events, perf
The Competing Consumers pattern enables multiple concurrent workers to process messages from the same queue, with each message handled by exactly one consumer.
The Pipes and Filters pattern decomposes complex data processing into a chain of independent, reusable filters connected by pipes. Each filter performs a single
The Priority Queue pattern enables systems to process messages based on importance rather than arrival order, ensuring high-priority requests receive preferenti
The Publisher/Subscriber (pub-sub) pattern decouples message producers from consumers by introducing an intermediary message broker. Publishers send messages to
Queue-based load leveling uses a message queue as a buffer between producers and consumers to absorb traffic spikes and prevent downstream service overload. The
The Scheduling Agent Supervisor pattern coordinates distributed actions as a single logical operation by using a supervisor to monitor agent progress, detect fa
Sequential Convoy processes related messages in strict order without blocking unrelated message groups. Messages are grouped by session ID or partition key, ens
Data management patterns address the fundamental challenge of distributed systems: how to store, access, and maintain data across multiple nodes while balancing
Cache-aside (also called lazy loading) puts the application in control of cache management: the app checks the cache first, loads from the database on miss, and
CQRS separates read (query) and write (command) operations into distinct models, allowing each to be optimized independently. Commands modify state through a wr
Event Sourcing stores every state change as an immutable event in an append-only log, rather than persisting only current state. The current state is reconstruc
The Index Table pattern creates separate lookup tables optimized for non-primary-key queries, trading storage space and write complexity for fast read performan
Materialized views are pre-computed, denormalized query results stored as physical tables that trade storage space and update complexity for dramatically faster
Sharding is a horizontal partitioning strategy that splits a large dataset across multiple independent database servers (shards), where each shard contains a su
Static Content Hosting is a cloud design pattern where unchanging files (HTML, CSS, JavaScript, images, videos) are served directly from object storage services
The Valet Key pattern provides clients with time-limited, scoped tokens that grant direct access to specific cloud resources (like storage or queues) without ro
Design and implementation patterns address how you structure, organize, and build cloud systems for maintainability, reusability, and operational excellence. Th
The Ambassador pattern places a helper proxy service alongside your application to handle cross-cutting networking concerns like retries, circuit breaking, moni
An Anti-Corruption Layer (ACL) is a translation boundary that sits between your domain model and external systems with different semantics, preventing legacy or
The Backend for Frontend (BFF) pattern creates dedicated backend services for each client type (web, mobile, IoT) instead of forcing all clients to use a single
Compute Resource Consolidation is the practice of combining multiple tasks, services, or workloads onto fewer computational units to maximize resource utilizati
External Config Store moves configuration data out of application deployment packages into a centralized, external system. Instead of baking configs into Docker
Gateway Aggregation consolidates multiple backend service calls into a single request, reducing client complexity and network overhead. The gateway acts as a sm
Gateway Offloading moves shared cross-cutting concerns (SSL/TLS termination, authentication, compression, rate limiting) from backend services to a centralized
Gateway Routing consolidates multiple backend services behind a single entry point, intelligently directing requests based on URL paths, headers, or other crite
Leader election is a coordination pattern where distributed nodes automatically select one instance as the leader to coordinate work, manage shared resources, o
Pipes & Filters decomposes complex data processing into independent, reusable filter components connected by pipes (channels). Each filter performs one transfor
The Sidecar pattern deploys auxiliary functionality (logging, monitoring, proxying, security) as a separate process that runs alongside your main application, s
Static content hosting serves unchanging assets (HTML, CSS, JS, images, videos) directly from cloud storage services like S3, Azure Blob Storage, or GCS, bypass
The Strangler Fig pattern enables incremental legacy system modernization by gradually replacing old functionality with new services while keeping the system ru
CQRS (Command Query Responsibility Segregation) separates write operations (commands) from read operations (queries) using different models, often with separate
Containerization packages applications with their dependencies into isolated, portable units that run consistently across environments. Orchestration automates
Serverless architecture lets you build applications without managing servers—you write code, the cloud provider handles infrastructure, scaling, and availabilit