Enterprise Architecture Patterns Course

Enterprise Architecture Patterns: From Monoliths to Planet-Scale Systems is a staff-level course on system architecture — not Gang-of-Four design patterns.

Good architecture is not minimal lines of code or the trendiest topology — it is the set of structures that let Amazon-scale teams change the system safely while meeting explici…

Quality attributes — availability, latency, scalability, security, modifiability — are the non-functional requirements that determine whether Netflix survives peak streaming hours.

Architectural scalability is the ability to grow traffic, data, teams, and geography without redesigning core structures.

Availability is the proportion of time a system correctly performs its work — measured as nines against explicit SLOs, not uptime of individual VMs.

Reliability is the probability that a system performs correctly over time — correctness under failure, not just uptime.

Maintainability is how cheaply a system absorbs change — new features, bug fixes, dependency upgrades, and team turnover — without proportional risk or toil.

Observability is the ability to infer internal system state from external outputs — metrics, logs, traces, and events — to answer novel questions during incidents.

Architectural trade-offs are the explicit choices between competing quality attributes — consistency vs availability, speed vs safety, cost vs performance.

Architecture Decision Records (ADRs) capture significant decisions with context, alternatives, and consequences — lightweight documents that prevent future teams from relitigati…

Strategic design in Domain-Driven Design maps business domains to bounded contexts, defines context relationships, and aligns team topology before tactical patterns like aggrega…

Bounded contexts delimit a domain model's applicability — inside the boundary, terms and rules are consistent; across boundaries, integrate via translation, not shared entities.

Ubiquitous language is the shared vocabulary between domain experts and engineers — reflected in code, docs, and conversation without translation layers.

Aggregates cluster entities and value objects with one root that enforces invariants transactionally — the consistency boundary for writes in DDD.

Entities are domain objects with identity that persists through state changes — distinguished by ID, not attribute values.

Value objects describe attributes without identity — immutable, compared by value, and safe to share.

Domain events record something meaningful that happened in the domain — past tense, immutable facts consumed by other aggregates and contexts.

Repositories persist and rehydrate aggregates — collection-like interface hiding persistence technology from domain layer.

Modular monolith keeps a single deployable artifact while enforcing hard module boundaries inside the codebase — each module owns its schema slice, exposes a narrow public API,…

Layered architecture organizes code into horizontal tiers — presentation, application, domain, infrastructure — with strict dependency direction downward.

Hexagonal architecture (ports and adapters) places the domain at the center, surrounded by ports (interfaces) and adapters (implementations) for every external system.

Clean Architecture (Uncle Bob) organizes code in concentric rings — Entities, Use Cases, Interface Adapters, Frameworks — with the Dependency Rule: source code dependencies poin…

Onion architecture (Jeffrey Palermo) wraps the domain model in layers of interfaces — Domain Model at core, Domain Services, Application Services, Infrastructure — with all depe…

Service decomposition splits a system into independently deployable services aligned to business capabilities or subdomains — not technical layers.

Database per service gives each microservice exclusive ownership of its persistence — no other service reads or writes its tables directly.

The shared database anti-pattern occurs when multiple microservices read and write the same database schema — creating a distributed monolith with network overhead and none of t…

An API gateway is the single entry point for client traffic — handling routing, authentication, rate limiting, request aggregation, and protocol translation before requests reac…

Backend for Frontend (BFF) is a dedicated backend service per client type (web, iOS, Android) that aggregates microservice calls and shapes responses for that client's UX needs.

Service discovery lets microservices find each other's current network location (IP, port, health) without hardcoded hostnames — essential when containers scale and reschedule c…

A service registry is the authoritative datastore of service instances, metadata, and health status that discovery clients query — Eureka, Consul, etcd (K8s), and ZooKeeper (leg…

Saga pattern coordinates long-running business transactions across multiple services without a distributed two-phase commit.

Transactional outbox guarantees that domain state changes and outbound messages commit atomically in one local database transaction.

Command Query Responsibility Segregation (CQRS) separates write models (commands, transactional consistency) from read models (queries, denormalized projections).

Event sourcing persists state as an append-only sequence of domain events rather than mutable rows.

Distributed transactions coordinate commits across multiple services or databases.

Idempotency ensures repeated identical requests produce the same outcome as a single execution — the foundation of safe retries in distributed systems.

Retry pattern re-invokes failed operations with controlled backoff and jitter when failures are transient — timeouts, 503s, partition leader elections.

Circuit breaker stops calling a failing dependency after error threshold, failing fast locally while the dependency recovers — then probes with half-open trials.

Bulkhead pattern isolates resources (thread pools, connections, queues) per dependency or tenant so failure in one compartment cannot sink the entire ship.

Rate limiting caps request volume per client, tenant, or endpoint — protecting backends from abuse, accidental loops, and flash crowds.

Event brokers are the durable transport layer between producers and consumers — SNS/SQS, Amazon MSK, Google Pub/Sub, Azure Event Hubs.

Apache Kafka is a distributed commit log — partitions, replicas, consumer groups, and ISR management form the core architecture LinkedIn pioneered for activity streaming.

RabbitMQ implements AMQP messaging with exchanges, queues, bindings, and acknowledgments — ideal for complex routing, RPC-over-messaging, and work-queue patterns.

Event streaming treats the continuous flow of domain events as a first-class data product — not a side effect of CRUD APIs.

Choreography coordinates distributed workflows through events alone — no central orchestrator.

Orchestration coordinates multi-step distributed workflows from a central process manager that invokes services and tracks state.

Kubernetes patterns are the operational primitives staff architects use to run distributed systems on container orchestration — deployments, services, ingress, HPA, PDB, and wor…

The sidecar pattern deploys a helper container alongside the application container in the same pod — sharing network namespace and optionally volumes.

The ambassador pattern deploys a proxy container that simplifies outbound connections for the application — handling retries, circuit breaking, TLS, and protocol translation.

The adapter pattern in cloud-native systems normalizes heterogeneous external interfaces — legacy protocols, varied config formats, different logging APIs — into a consistent in…

A service mesh is a dedicated infrastructure layer for service-to-service communication — typically implemented as sidecar proxies (data plane) managed by a control plane.

Istio is the dominant open-source service mesh implementation — Envoy data plane, Istiod control plane, and Kubernetes-native CRDs for traffic, security, and observability.

Strangler Fig incrementally replaces a legacy system by routing traffic slice-by-slice to new implementations while the old system continues running.

Branch By Abstraction introduces an abstraction layer (interface) in front of a module you plan to replace, routes all callers through the abstraction, then swaps the implementa…

Anti-Corruption Layer (ACL) is a translating boundary that isolates your domain model from legacy or external systems whose vocabulary, invariants, and failure modes would corru…

Legacy Modernization is the disciplined program — not a single pattern — of evolving outdated systems toward target architecture using Strangler Fig, Branch By Abstraction, ACL,…

Multi-Tenant Shared Database stores all tenants' data in one physical database cluster, discriminating rows by a tenant_id column (or equivalent).

Multi-Tenant Shared Schema gives all tenants identical table structures within a database — the most common SaaS pattern.

Multi-Tenant Separate Schema gives each tenant (or tenant tier) its own namespace within a shared database instance — tenant_a.listings vs tenant_b.listings.

Multi-Tenant Separate Database provisions each tenant (or tenant tier) with its own database instance or cluster — maximum isolation, highest cost and operational complexity.

Tenant Isolation is the cross-cutting quality attribute — not a storage model — ensuring one tenant's load, failures, and security boundaries cannot impact another.

Staff Engineer Architecture Interviews evaluate whether a candidate operates at organizational scope: defining technical direction across teams, making irreversible trade-offs l…

System Design Architecture Interviews at Amazon evaluate whether candidates can design production systems under real constraints — scale, cost, failure modes, and operability —…

Architecture Trade-offs Interview focuses exclusively on decision quality: given competing quality attributes (latency vs consistency, velocity vs isolation, cost vs availabilit…

Architecture Whiteboarding is the skill of communicating system design in real time — boxes, arrows, and narrative that a mixed audience (engineers, PMs, bar-raisers) can follow.