Microservices

Translation boundary protecting a bounded context's model from upstream language corruption; structure (FACADE+ADAPTER); ACL vs Conformist vs Open-Host Service; migration use with Strangler Fig

Gateway taxonomy (enterprise/microservices/mesh), capabilities, pitfalls, history

Modularity drivers (availability, scalability, deployability, testability, maintainability); scalability vs elasticity; component-based vs tactical forking; six decomposition patterns; architecture stories

Summary and comparison of all 8 styles; decision guide

All 8 architecture styles rated side by side; decision guide; monolith vs understanding-distributed-systems; partitioning type

DDD strategic design: subdomain taxonomy (core/generic/supporting), bounded context definition, subdomains vs bounded contexts, physical/ownership boundaries, sizing heuristic (start wide), subdomain type evolution (all 6 transitions), growth management; Evans' originating treatment: Continuous Integration within context, false cognates vs duplicate concepts, context sizing trade-offs

Migration for deeply embedded capabilities: 5 steps; feature toggles; verify variant with automatic fallback

*Building Event-Driven Microservices* — Adam Bellemare

Resource partitioning, shuffle sharding, cellular architecture

Closed/open/half-open state machine for downstream resiliency

Four reuse techniques: code replication, shared library, shared service, sidecar; core reuse principle (reuse = abstraction + slow rate of change); versioning discipline; orthogonal coupling

Six bounded context integration patterns grouped by team collaboration type; context map notation; model translation: stateless proxy (sync/async) and stateful aggregation (stream processing, BFF); private vs public events; Evans' originating eight-pattern taxonomy (Shared Kernel, Customer/Supplier, Conformist, ACL, Separate Ways, OHS, Published Language, CI) and transformation recipes

Strict/loose contract spectrum; consumer-driven contracts; stamp coupling; event schema evolution (forward/backward/full compatibility); schema registry; event design anti-patterns; Newman: structural vs semantic breakages, expansion changes, dual-version strategies; EIP: Format Indicator (version number/foreign key/embedded schema), Canonical Data Model

Coupling taxonomy: structural (Ca/Ce, Martin A/I/D, connascence), operational (Newman's implementation/temporal/deployment/domain types), contract (strict/loose, stamp coupling), integration-style spectrum (File Transfer → Messaging); coupling and quantum boundaries; coordinated deployments as coupling signal; concept leakage and flatten-when-publishing

How far to decompose: modular monolith → service-based → microservices; five decision factors (domain understanding, team structure, DevOps maturity, transaction requirements, scalability); recommended migration path; granularity disintegrators vs integrators; Ferrari anti-pattern

Broker vs mediator topologies; DDD: three event types (notification, ECST, domain event); private vs public events; distributed big ball of mud anti-pattern; data liberation

The 8 fallacies (Deutsch/Sun 1994): network reliable, latency zero, bandwidth infinite, network secure, topology fixed, one admin, transport free, homogeneous network; stamp coupling; distributed logging/transactions/contracts

Eight types of natural split points for monolith decomposition: business domain (primary), regulatory compliance, change cadence, team location, risk, performance, technology (sparingly), user personas; six forms of monolith; distributed monolith anti-pattern

*Fundamentals of Software Architecture* — Richards & Ford

*Learning Domain-Driven Design* — Vlad Khononov

Author of *Fundamentals of Software Architecture* (with Ford), *Software Architecture Patterns*, *Software Architecture: The Hard Parts*

*Mastering API Architecture* — Gough, Bryant, Auburn

Fine-grained domain services; maximum quanta; highest agility/cost; DDD: deep module heuristic, BC vs microservice relationship, subdomain as safe granularity, OHS/ACL for deeper services

*Monolith to Microservices* — Sam Newman

Decision guide: when to use a central coordinator vs event-driven choreography; team-ownership heuristic; God Orchestrator anti-pattern; workflow state management options

Atomic write + publish without 2PC; relay process; CDC; data liberation patterns; DDD: two wrong approaches + correct approach; NoSQL embedding; pull vs push relay

Correctness verification: both implementations run per request; old result returned; GitHub Scientist; dark launching vs canary vs parallel run; progressive delivery

Transient failure recovery; exponential backoff with jitter; retry amplification in chains; idempotency prerequisite; retry queues

Distributed transactions via local transactions + compensations; 8 saga type taxonomy; semantic vs implementation coupling; orchestration/choreography trade-offs; DDD: saga vs process manager distinction; stateless/stateful saga; process manager as aggregate; Newman: backward/forward recovery, semantic rollbacks, step reordering, team-based coordination choice

Granularity vs modularity distinction; six disintegrators; four integrators; volatility-based decomposition; MTTS; trade-off-to-business-question method

East–west traffic governance: mTLS, service authorisation, evolution from libraries to eBPF; sidecar as reuse mechanism for operational concerns; orthogonal coupling; data-sinking sidecar for EDM legacy integration

*Software Architecture Patterns* — Mark Richards

Incremental migration pattern: identify → implement → redirect via proxy; HTTP/FTP/message variants; UI composition (page, widget, micro frontends); deployment ≠ release; feature freeze

Sweller's three cognitive load types (intrinsic/extraneous/germane); team cognitive capacity as software boundary constraint; domain complexity heuristics; platform as extraneous load eliminator

Technical (layered) vs domain (bounded context) top-level component design

Bounding wait time on every blocking call; sizing by P99.9; absent-timeout gotchas; relationship to circuit breaker and retry