#design-patterns

Explains the hostname routing pattern, which isolates API services by giving each one its own hostname, with typical use cases and trade-offs.

Explains the HTTP header routing pattern, where a request header selects the target service, action, version, or feature, along with its pros and cons.

Explains the path routing pattern, which groups APIs under one hostname and separates services by URI, with NGINX, API Gateway, and CloudFront implementations on AWS.

Describes the Circuit Breaker pattern, which stops a caller from repeatedly calling a failing or slow service, its three states, and how to build it on AWS.

Describes the Event Sourcing pattern, which stores every state-changing event in an immutable event store and rebuilds state by replay, with challenges and AWS implementations.

Describes the Hexagonal Architecture (Ports and Adapters) pattern for loosely coupled, independently testable applications, including how to apply it on AWS Lambda.

Describes the Retry with Backoff pattern, which automatically retries operations that failed from transient errors using exponential backoff and jitter, with AWS implementations.

Describes the Saga Choreography pattern, which keeps data consistent across services through event subscriptions instead of a central coordinator, with an AWS order-flow example.

Describes the Saga Orchestration pattern, which uses a central orchestrator such as AWS Step Functions to coordinate distributed transactions and compensating actions.

Describes the Strangler Fig pattern for incrementally migrating a monolith to microservices behind a proxy layer, with AWS implementations, benefits, and challenges.

Describes the Transactional Outbox pattern, which solves the dual-write problem by saving events in the same transaction as the data, using an outbox table or change data capture.

Explains how an ambassador helper service acts as an out-of-process proxy that sends network requests on behalf of a client, adding resiliency, routing, and security without changing the application.

Describes how a façade or adapter layer translates between subsystems with different semantics so a new application's design is not constrained by legacy or external systems.

Explains how to decouple long-running backend processing from the frontend using HTTP 202 and a polling status endpoint, with an Azure Functions implementation outline.

Describes creating a separate backend service per client interface so each frontend gets a tailored experience instead of forcing one shared backend to serve conflicting needs.

Explains how isolating application components into separate resource pools keeps a failure or overload in one pool from cascading, with a Kubernetes resource-limit example.

Explains how to load data into a cache on demand from a data store, and how to invalidate entries on update to keep the cache consistent, with a .NET example.

Describes decentralizing workflow logic across services that react to each other's events through a message broker, instead of relying on a central orchestrator.

Explains how a circuit-breaker proxy with Closed, Open, and Half-Open states stops an application from repeatedly calling a failing remote service and prevents cascading failures.

Explains how to move large payloads out of a messaging system by storing them externally and sending only a claim-check token, with Azure Blob Storage and Service Bus examples.

A catalog of Azure cloud design patterns with one-line summaries and the Well-Architected pillars each one supports, plus the distributed-computing fallacies they address.

Explains how to undo the steps of an eventually consistent, multi-step operation by running compensating actions instead of a traditional ACID rollback, with a travel-booking example.

Explains how multiple consumers can process messages from a single queue concurrently to improve throughput, scalability, and availability, including poison-message and idempotency concerns.

Describes consolidating multiple tasks into a single computational unit to raise resource utilization and cut cost, and the scalability, lifetime, security, and contention trade-offs involved.

Covers Command Query Responsibility Segregation, which splits read and write operations into separate models to improve performance, scalability, and security.

Describes deploying multiple independent copies of a scale unit (stamps) to host different tenants, gaining near-linear scale, limited blast radius, and regional data placement.

Describes how to manage and distribute configuration to edge workloads that must keep running offline, comparing an external configuration controller with an internal configuration provider.

Explains storing every change to an entity as an immutable sequence of events in an append-only store, with materialized views, replay, snapshots, and trade-offs.

Explains moving configuration out of the deployment package into a centralized store to avoid redeploys and share settings, with Azure App Configuration and Key Vault options.

Explains delegating authentication to an external identity provider using claims-based tokens for single sign-on, less admin overhead, and stronger security, with Microsoft Entra ID examples.

Explains protecting services with a dedicated, low-privilege broker that validates and sanitizes requests before handing them to a trusted host, shrinking the attack surface.

Explains using a gateway to combine multiple client requests into one, cutting chattiness and latency between clients and backend services.

Explains offloading shared cross-cutting functions such as SSL termination, authentication, and throttling to a gateway proxy so individual services stay simpler.

Explains routing requests to multiple services or service versions through a single layer-7 gateway endpoint, enabling backend abstraction and zero-downtime deployments.

Explains deploying self-contained backend nodes across geographic regions in an active-active setup so any node can serve any request, cutting latency and surviving regional outages.

Explains exposing application health-check endpoints that external monitoring tools poll to verify dependencies, response codes, and latency, plus security and caching considerations.

Explains emulating secondary indexes in NoSQL stores with separate index tables, comparing denormalized, normalized, and partially normalized layouts and their consistency costs.

Explains coordinating distributed instances by electing one leader via a distributed mutex or consensus algorithm, including heartbeat, lease, and failure considerations.

Explains generating prepopulated, read-only views over source data to speed up complex queries, with event-driven or scheduled refresh and eventual-consistency trade-offs.

Explains building a bridge component that relays messages between incompatible messaging infrastructures, such as MSMQ and Azure Service Bus, without changing existing systems.

A table of contents for the system design notes, covering fundamentals, software architecture, technical solutions, resilience patterns, and attachments.

A survey of software architecture patterns (Clean, Hexagonal, Microservices, EDA, DDD, CQRS, LMAX, MVC family) and design principles (SOLID, DRY, AOP, Command Bus), with references and examples.