Software Architecture
Navigation

Software Architecture

Overview

  • Overview — Evolving synthesis of software architecture as a discipline

Architecture Styles

  • Architecture Styles — Summary and comparison of all 8 styles; decision guide (informed by: fundamentals-of-software-architecture)
  • Event Driven Architecture — 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 (informed by: fundamentals-of-software-architecture, building-event-driven-microservices, learning-domain-driven-design)
  • Layered Architecture — Technical partitioning; simplest monolith; domain layer isolation as the DDD prerequisite; Smart UI anti-pattern; sinkhole anti-pattern; closed/open layers (informed by: fundamentals-of-software-architecture, software-architecture-patterns, learning-domain-driven-design, domain-driven-design)
  • Ports And Adapters — Hexagonal/onion/clean architecture; DIP-inverted dependencies; business logic at centre; DDD fit: domain model and event-sourced domain model; architectural slices principle (informed by: learning-domain-driven-design)
  • Microkernel Architecture — Core system + plug-ins; single quantum; customisability-focused (informed by: fundamentals-of-software-architecture)
  • Microservices Architecture — 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 (informed by: fundamentals-of-software-architecture, understanding-distributed-systems, learning-domain-driven-design)
  • Pipeline Architecture — Filter-and-pipe; technically partitioned; ETL/data processing; EIP treats Pipes and Filters as a messaging composition pattern (informed by: fundamentals-of-software-architecture, enterprise-integration-patterns)
  • Service Based Architecture — 4–12 coarse domain services; pragmatic middle ground; supports ACID (informed by: fundamentals-of-software-architecture)
  • Modular Monolith — Domain-partitioned single quantum; appropriate coupling via fitness function enforcement; intermediate migration step (informed by: building-evolutionary-architectures)
  • Soa Architecture — Orchestration-driven SOA; technically partitioned; legacy enterprise pattern (informed by: fundamentals-of-software-architecture)
  • Space Based Architecture — In-memory replicated cache; extreme performance/scalability; high cost (informed by: fundamentals-of-software-architecture)

Concepts

DDD / Domain Design

  • Bounded Contexts — 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 (informed by: domain-driven-design, building-event-driven-microservices, learning-domain-driven-design)
  • Ubiquitous Language — DDD cornerstone practice: shared business language eliminating translation chains; must pervade the code; modeling out loud; documents must track UL or be archived; UML limitations; explanatory models as separate teaching aids (informed by: domain-driven-design, learning-domain-driven-design)
  • Model Driven Design — Evans' binding principle: one model for analysis and design; code is the model's expression; hands-on modellers; bones-showing; requires layered architecture for domain isolation; breakthroughs: non-linear returns, cascade of insights, Share Pie story (informed by: domain-driven-design)
  • Supple Design — Evans' six patterns for design that is easy to work with and extend: Intention-Revealing Interfaces, Side-Effect-Free Functions, Assertions, Conceptual Contours, Standalone Classes, Closure of Operations; declarative style as outcome (informed by: domain-driven-design)
  • Core Domain — strategic distillation: CORE DOMAIN identification, generic subdomains, domain vision statement, highlighted core, cohesive mechanisms, segregated core, abstract core; escalation of distillation techniques (informed by: domain-driven-design)
  • Large Scale Structure — organising principle for entire system; four patterns: System Metaphor, Responsibility Layers (Potential/Operations/Decision Support/Policy/Commitment), Knowledge Level, Pluggable Component Framework; Evolving Order; six essentials for strategic design (informed by: domain-driven-design)
  • Eventstorming — Low-tech collaborative workshop; 10-step process (domain events, commands, policies, aggregates, bounded context candidates); when to use; two-phase facilitation; remote considerations; Rosa: Big Picture EventStorming for domain boundary/KPI mapping + KPI Value Tree; Process Modeling EventStorming for operational value stream analysis (informed by: learning-domain-driven-design, monolith-to-microservices, software-architecture-metrics)
  • Conways Law — Conway's Law; Inverse Conway Maneuver; three organisational structures (Pflaeging); tool choices as communication drivers; unexpected communication as diagnostic signal; organisation design as technical work (informed by: building-evolutionary-architectures, team-topologies)
  • Continuous Delivery Practices — Eight Accelerate-validated CD capabilities; key empirical findings: config-in-VCS more predictive than code, developer-owned tests, trunk-based development, loosely coupled architecture as the single largest CD lever; shift-left security (DevSecOps); lightweight change approval vs CABs; relationship between CD, culture, burnout, and job satisfaction (informed by: accelerate, building-evolutionary-architectures)
  • Team Topologies Model — Four team types (stream-aligned, platform, enabling, complicated-subsystem); three interaction modes with constraints/matrix; Dunbar-based team sizing; team API; one-owner-per-component rule; promise theory / SemVer; organisational sensing; discovery-to-establish pattern; topology evolution triggers; TVP; fractal platforms; Spotify model; DevOps anti-patterns (informed by: team-topologies)
  • Cognitive Load — Sweller's three cognitive load types (intrinsic/extraneous/germane); team cognitive capacity as software boundary constraint; domain complexity heuristics; platform as extraneous load eliminator (informed by: team-topologies)
  • Fracture Planes — 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 (informed by: team-topologies)
  • Westrum Culture — Ron Westrum's organisational culture typology (pathological/bureaucratic/generative); information flow as core mechanism; Likert measurement with psychometric validation; predicts delivery performance, org performance, job satisfaction; how to improve culture (implement practices first); blameless postmortems; Google Project Aristotle alignment (informed by: accelerate)

Architecture Practice

  • Adrs — Architecture Decision Records: structure, anti-patterns, compliance governance, Type 1/2 decisions (informed by: fundamentals-of-software-architecture, mastering-api-architecture)
  • Architect Soft Skills — Diagramming, presenting, team leadership (architect personality types, elastic leadership, team warning signs, checklists), negotiation (4 C's, stakeholder/architect/developer tactics), career (20-minute rule, personal technology radar) (informed by: fundamentals-of-software-architecture)
  • Architectural Decomposition — Modularity drivers (availability, scalability, deployability, testability, maintainability); scalability vs elasticity; component-based vs tactical forking; six decomposition patterns; architecture stories (informed by: software-architecture-the-hard-parts)
  • Architecture Characteristics — The "-ilities": taxonomy, selection, measurement, governance (informed by: fundamentals-of-software-architecture)
  • Architecture Documentation — Purpose and audience taxonomy; C4 / UML / ArchiMate notations; ADRs as the durable documentation form; diagrams-as-code; "just sufficient" principle; presentation craft (two-channel model, infodecks vs presentations, Bullet-Riddled Corpse anti-pattern) (informed by: fundamentals-of-software-architecture, building-evolutionary-architectures, learning-domain-driven-design, mastering-api-architecture)
  • Architecture Quantum — Independently deployable artifact; static/dynamic coupling distinction; quantum count by architecture style; micro-frontends (including EDM pairing); 3D dynamic coupling space → 8 saga types (informed by: fundamentals-of-software-architecture, building-evolutionary-architectures, software-architecture-the-hard-parts, building-event-driven-microservices)
  • Cost As Architectural Force — Cost as first-class quality attribute; five cost dimensions (build/run/change/downtime/opportunity); architecture style as dominant cost driver; ROI patterns (deployment automation 18×, observability, stability patterns); common cost traps; cost-vs-other-ilities trade-offs (informed by: release-it, foundations-of-scalable-systems, fundamentals-of-software-architecture, building-evolutionary-architectures, site-reliability-engineering)
  • Coupling — 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 (informed by: fundamentals-of-software-architecture, software-architecture-the-hard-parts, monolith-to-microservices, building-evolutionary-architectures, enterprise-integration-patterns, release-it)
  • Deployment Pipelines — Fitness function automation; stages, fan-in/fan-out; CD vs CDP; cycle time as business metric; zero-downtime deployment (four phases: prepare/drain/apply/start); expand/contract relational schema pattern; trickle-then-batch schemaless migration; canary group evaluation; immutable infrastructure; EDM deployment patterns (informed by: building-evolutionary-architectures, understanding-distributed-systems, mastering-api-architecture, building-event-driven-microservices, release-it)
  • Evolutionary Architecture — Three pillars; evolvability by style; strangler fig; six Rs; guidelines; antipatterns; DDD brownfield modernisation strategy; "form follows failure"; bad layering (horizontal coupling); component-based decomposition; decision loop speed and thrashing; service extinction; Farley: testability+deployability as operational drivers, TDD as architectural feedback, architectural descriptions as "tourist maps" (informed by: building-evolutionary-architectures, mastering-api-architecture, fundamentals-of-software-architecture, learning-domain-driven-design, monolith-to-microservices, release-it, software-architecture-metrics)
  • Evolutionary Database Design — Expand/contract pattern; Flyway/Liquibase; shared DB decomposition; reporting antipattern; Newman's ~12 database decomposition patterns (database view, wrapping service, tracer write, synchronize in application, etc.) (informed by: building-evolutionary-architectures, monolith-to-microservices)
  • Feature Flags — Application-layer release control; Hodgson's four toggle types (release/experiment/ops/permission) with different lifecycles; flag lifecycle discipline; default behaviour and cohort routing; kill switches and load-shedding flags; flags as technical debt with a use-by date (informed by: building-evolutionary-architectures, understanding-distributed-systems, accelerate, monolith-to-microservices, release-it)
  • Fitness Functions — Full classification taxonomy; priority tiers; enterprise fitness functions; mechanism and concern taxonomies; fitness function testing pyramid (triggered/continuous × atomic/holistic → three pyramid layers); ISO 25010 quality attribute anchoring (informed by: building-evolutionary-architectures, fundamentals-of-software-architecture, mastering-api-architecture, software-architecture-metrics)
  • Four Key Metrics — DORA four key metrics (deployment frequency, lead time for changes, change failure rate, time to restore service); empirical basis (4-year, 23K+ respondents, Accelerate); Lean conceptual basis; cluster analysis; no-tradeoff finding; CABs negatively correlated with both metrics; Goodhart's Law warning; pipeline topology variants; instrumentation; MVD; virtuous cycle mechanism; complementary metrics (informed by: accelerate, software-architecture-metrics)
  • Goal Question Metric — GQM framework (Basili & Weiss 1984): goal → questions → metrics → data tree; goal statement structure (purpose/object/issue/viewpoint); metric selection criteria (signal strength, cost, cross-question reuse); 9-step workshop; Foo Service case study (rate-limit incident → heartbeat + fail-fast ADR → 10-minute detection before user impact) (informed by: software-architecture-metrics)
  • Modularity — Cohesion types, LCOM, coupling metrics, connascence taxonomy (static vs dynamic); SATH: applying D/A/I metrics to decomposition feasibility; Modularity Maturity Index (MMI 0-10, three cognitive principles: modularity 45%/hierarchy 30%/pattern consistency 25%, decision thresholds, architecture erosion, implementation vs design/architecture debt); advanced structural metrics: ACD/CCD/Propagation Cost, Relative Cyclicity, SDI, Maintainability Level, LCOM4, change history metrics, Component Rank, six golden rules (informed by: fundamentals-of-software-architecture, software-architecture-the-hard-parts, software-architecture-metrics)
  • Reuse Patterns — Four reuse techniques: code replication, shared library, shared service, sidecar; core reuse principle (reuse = abstraction + slow rate of change); versioning discipline; orthogonal coupling (informed by: software-architecture-the-hard-parts)
  • Risk Storming — Collaborative risk identification: risk matrix, risk assessment, 3-activity process (informed by: fundamentals-of-software-architecture)
  • Service Granularity — Granularity vs modularity distinction; six disintegrators; four integrators; volatility-based decomposition; MTTS; trade-off-to-business-question method (informed by: software-architecture-the-hard-parts)
  • Software Complexity — Ousterhout's complexity definition: three symptoms (change amplification, cognitive load, unknown unknowns), two causes (dependencies, obscurity), incremental accumulation; strategic vs. tactical programming; technical debt as borrowed time (informed by: a-philosophy-of-software-design)
  • Stability Patterns — Coherent navigation hub for Nygard's stability pattern set; failure-arresting (timeout/circuit-breaker/bulkhead), load-handling (shed load/backpressure/handshaking), defensive (fail fast/let it crash/steady state/retry), and architectural (decoupling middleware/test harnesses/governor); pattern composition; antipatterns they defend against (informed by: release-it, understanding-distributed-systems, foundations-of-scalable-systems, site-reliability-engineering)
  • Technical Vs Domain Partitioning — Technical (layered) vs domain (bounded context) top-level component design (informed by: fundamentals-of-software-architecture)

API & Integration

  • Api Design — REST, gRPC, GraphQL exchange format decision; HTTP methods; URL modeling; status codes; OAS; versioning; Postel's Robustness Principle; non-breaking vs breaking changes; implementation-as-de-facto-spec; version translation in controllers; API-first (informed by: mastering-api-architecture, understanding-distributed-systems, building-event-driven-microservices, release-it)
  • Api Gateway — Gateway taxonomy (enterprise/microservices/mesh), capabilities, pitfalls, history (informed by: mastering-api-architecture)
  • Api Testing — Test pyramid, consumer-driven contracts, Pact, component/integration/E2E testing; scope vs size distinction, test double fidelity hierarchy, user journey tests, formal verification with TLA+; EDM topology testing, integration testing strategies, event data sourcing (informed by: mastering-api-architecture, understanding-distributed-systems, building-event-driven-microservices)
  • Contracts — 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 (informed by: software-architecture-the-hard-parts, mastering-api-architecture, building-event-driven-microservices, monolith-to-microservices, enterprise-integration-patterns)
  • Integration Styles — the four EIP integration styles (File Transfer, Shared Database, RPI, Messaging); eight decision criteria; trade-offs and when to use which style (informed by: enterprise-integration-patterns)
  • Messaging — Command/Document/Event message types; one-way/req-resp/broadcast styles; Request-Reply (sync block vs async callback; Return Address; Correlation Identifier); point-to-point/pub-sub/datatype channels; Pub-Sub as distributed Observer (push vs pull; channel design); at-least-once delivery; guaranteed delivery; exactly-once via idempotency; invalid vs dead letter channel; backlogs; poison message isolation; competing consumers; data safety trade-off (publisher confirms + persistent queues + manual ACKs); quorum queues (RAFT); RabbitMQ internals; Pipes and Filters; Message Router; Message Bus; Messaging Bridge; Aggregator; Resequencer; Composed Message Processor; Scatter-Gather; Routing Slip; Process Manager; Message Broker (architectural pattern); Envelope Wrapper; Content Enricher; Content Filter; Claim Check; Normalizer; Canonical Data Model; Messaging Gateway; Messaging Mapper; Transactional Client; Polling Consumer; Event-Driven Consumer; Competing Consumers; Message Dispatcher; Selective Consumer; Durable Subscriber; Idempotent Receiver; Service Activator; Control Bus; Detour; Wire Tap; Message History; Message Store; Smart Proxy; Test Message; Channel Purger (informed by: understanding-distributed-systems, enterprise-integration-patterns, release-it, foundations-of-scalable-systems)
  • Oauth2 And Authn — OAuth2 roles, JWT, grants (Auth Code, PKCE, Client Credentials), OIDC, refresh tokens (informed by: mastering-api-architecture)
  • Threat Modeling — STRIDE, DREAD, OWASP API Top 10, six-step process, rate limiting strategies (informed by: mastering-api-architecture)
  • Zero Trust — Zonal architecture critique, NCSC eight principles, service mesh + OAuth2 implementation stack (informed by: mastering-api-architecture)

AI & Machine Learning

  • Foundation Models — What foundation models are; transformer architecture (prefill/decode, KV cache, MoE); training data constraints; Chinchilla scaling law; post-training (SFT, RLHF, DPO) (informed by: ai-engineering)
  • Ai Engineering — AI engineering as a discipline vs ML engineering; three-layer stack (application dev, model dev, infrastructure); product planning; last-mile challenge; use case taxonomy (informed by: ai-engineering)
  • Llm Sampling — Sampling strategies (temperature, top-k, top-p); test-time compute; structured outputs; hallucination (self-delusion + knowledge-mismatch hypotheses); inconsistency mitigation (informed by: ai-engineering)
  • Ai Evals — Evaluation methodology: perplexity, pass@k, BLEU/ROUGE, embeddings, AI-as-a-judge, comparative evaluation (Elo/Bradley-Terry, LMSYS Arena); factual consistency, safety, instruction-following; model selection workflow; API vs self-hosting; evaluation pipeline design; benchmark contamination (informed by: ai-engineering)
  • Prompt Engineering — Prompt anatomy; system vs user prompt; chat templates; in-context learning (zero/few-shot, CoT); prompt decomposition; defensive prompt engineering (extraction, jailbreaking, injection, information extraction); three-layer defence (model/prompt/system) (informed by: ai-engineering)
  • Rag — Retrieval-augmented generation; term-based (TF-IDF, BM25) vs embedding-based retrieval; ANN algorithms (LSH, HNSW, FAISS); hybrid search with RRF; chunking; reranking; contextual retrieval; text-to-SQL; memory model (informed by: ai-engineering)
  • Ai Agents — Agent planning (ReAct, Reflexion); tool categories (knowledge, capability, write actions); function calling; multi-agent systems; planning/tool/efficiency failure modes; safety and compound errors; LLM planning debate (informed by: ai-engineering)
  • Finetuning — When to finetune vs RAG; memory bottleneck; quantisation (FP32→INT4); PEFT; LoRA (low-rank decomposition, rank, alpha, multi-LoRA serving); QLoRA; model merging (task arithmetic, TIES/DARE, frankenmerging); finetuning tactics (informed by: ai-engineering)
  • Dataset Engineering — Data-centric AI; three criteria (quality, coverage, quantity); acquisition and annotation; data synthesis (rule-based, simulation, AI-powered, reverse instruction); model distillation; model collapse; data processing pipeline (informed by: ai-engineering)
  • Inference Optimization — Inference metrics (TTFT, TPOT, throughput, goodput, MFU, MBU); prefill (compute-bound) vs decode (memory bandwidth-bound); speculative decoding; KV cache management (PagedAttention, FlashAttention, GQA/MQA); continuous batching; prefill-decode decoupling; prompt caching (informed by: ai-engineering)
  • Ai Engineering Architecture — Five-step progressive architecture (context enhancement, guardrails, router/gateway, caching, agents); model drift detection; orchestration frameworks; user feedback systems (explicit vs implicit, edit-as-preference, degenerate feedback loops, sycophancy) (informed by: ai-engineering)
  • Ml Systems Design — When to use ML (nine conditions); research vs production differences (silent failure, latency vs throughput, messy data, fairness, interpretability); four system requirements (reliability, scalability, maintainability, adaptability); business vs ML objective alignment; problem framing (task types, decoupling objectives); mind vs data debate (informed by: designing-machine-learning-systems)
  • Feature Engineering — Feature operations (missing value handling MNAR/MAR/MCAR, scaling, discretisation, categorical encoding/hashing trick, feature crossing, positional embeddings); data leakage causes and detection; feature importance (top 10 = 50% importance); feature generalisation (coverage × distribution overlap); best practices (split by time, scale after split) (informed by: designing-machine-learning-systems)
  • Model Development — Six model selection tips; four phases of ML adoption; ensembles (bagging/boosting/stacking); experiment tracking and data versioning challenges; ML debugging; distributed training (data/model/pipeline parallelism); AutoML (hyperparameter tuning, NAS, learned optimisers); offline evaluation baselines; evaluation methods (perturbation, invariance, directional expectation, calibration, confidence, slice-based/Simpson's paradox) (informed by: designing-machine-learning-systems)
  • Data Distribution Shifts — Covariate shift/label shift/concept drift/feature change/label schema change taxonomy; degenerate feedback loops (mechanism, detection, correction via randomisation and positional features); detection methods (KS test, two-sample tests, feature validation, prediction monitoring, sliding vs cumulative statistics); proactive design; retraining strategies (informed by: designing-machine-learning-systems)
  • Continual Learning — Stateless retraining vs stateful training (fine-tuning); four stages of continual learning maturity; champion/challenger pattern; test in production methods (shadow deployment, A/B testing, canary release, interleaving experiments, bandits, contextual bandits); data freshness value; continuous ML challenges (feedback loops, emergency response, stable A/B baselines) (informed by: designing-machine-learning-systems, reliable-machine-learning)
  • Mlops Infrastructure — Four-layer MLOps stack (storage/compute, resource management, ML platform, dev environment); cloud repatriation; Docker + Kubernetes; workflow orchestration tools (Airflow/Argo/Prefect/Metaflow); model store (8 artifact types); feature store (management/computation/consistency, eliminates training-serving skew); build vs buy framework (informed by: designing-machine-learning-systems)

Data

  • Data Decomposition — Data disintegrators/integrators; five-step process; data domains; data sovereignty; connection quotas; polyglot persistence; database type selection; data ownership (single/common/joint); eventual consistency patterns; four distributed data access patterns (informed by: software-architecture-the-hard-parts)
  • Data Mesh — Data Warehouse, Data Lake, Data Mesh evolution; four Data Mesh principles; DPQ; OLTP vs OLAP; star/snowflake schema; DDD/Data Mesh alignment (OHS as analytical published language, CQRS for projections) (informed by: software-architecture-the-hard-parts, learning-domain-driven-design)

Distributed Systems

  • Backpressure — Flow-control mechanism: downstream signals upstream to slow producers rather than overwhelm consumers; bounded queues vs unbounded; backpressure vs load shedding (internal vs boundary); credit-based flow control; pull-based streams; anti-patterns (unbounded queues, retries defeating backpressure) (informed by: release-it, foundations-of-scalable-systems, understanding-distributed-systems, designing-data-intensive-applications)
  • Broadcast Protocols — best-effort, reliable (eager/gossip), total order broadcast; consensus requirement; relationship to CRDTs and replication (informed by: understanding-distributed-systems)
  • Caching — HTTP caching (Cache-Control, ETag, fresh/stale, immutable static resources); reverse proxies; application-layer: side vs inline cache, LRU eviction, TTL, local vs external cache, thundering herd, cascading failure; 80% hit rate as scalability threshold (informed by: understanding-distributed-systems, foundations-of-scalable-systems)
  • Cap Theorem — CAP theorem and PACELC extension; Kleppmann's critique ("best avoided"); timeliness vs integrity distinction (informed by: understanding-distributed-systems, designing-data-intensive-applications)
  • Cdn — CDN overlay network; BGP limitations; global DNS LB; IXP placement; edge+intermediary caching layers; DDoS shielding (informed by: understanding-distributed-systems)
  • Consensus Algorithms — Raft, Paxos, Zab; FLP result; ZooKeeper/etcd; equivalence theorem (linearizable CAS = total order broadcast = locks = uniqueness) (informed by: designing-data-intensive-applications, understanding-distributed-systems)
  • Consistency Models — Full spectrum: linearizability, sequential, causal, strong eventual, eventual; COPS causal+ implementation; isolation levels; linearizability ≠ serializability; timeliness vs integrity; safety vs liveness (informed by: understanding-distributed-systems, designing-data-intensive-applications)
  • Control Plane Data Plane — data plane (on critical path, availability), control plane (off-path, consistency); static stability; scale imbalance solutions (file store buffer, push deltas, hybrid); control theory feedback loop (informed by: understanding-distributed-systems, mastering-api-architecture)
  • Crdts — Conflict-free Replicated Data Types; semilattice + LUB merge; strong eventual consistency; LWW/MV registers; CALM theorem (application-level consistency, not linearizability) (informed by: understanding-distributed-systems)
  • Distributed Transactions — ACID, 2PL, OCC, MVCC, 2PC, Spanner, Saga, Outbox; XA limitations; coordination-avoiding correctness; Newman's "just say no" to 2PC during migration (informed by: understanding-distributed-systems, designing-data-intensive-applications, monolith-to-microservices)
  • Dns — Hierarchical resolution process; TTL trade-offs; DNS as eventually consistent KV store; DNS as SPOF; static stability principle (informed by: understanding-distributed-systems)
  • Failure Detection — Timeouts (fundamental limitation), pings vs heartbeats, when to use active detection; imperfect failure detection theorem (informed by: understanding-distributed-systems)
  • Fallacies Of Distributed Computing — 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 (informed by: fundamentals-of-software-architecture)
  • Http — HTTP/1.1 vs HTTP/2 vs HTTP/3 (QUIC); multiplexing; HOL blocking; connection management; relationship to REST (informed by: understanding-distributed-systems)
  • Idempotency — Idempotency keys (atomicity requirement, principle of least astonishment), at-least-once delivery, retry safety (informed by: understanding-distributed-systems)
  • Leader Election — Raft state machine (follower/candidate/leader); election terms; CAS+lease practical approach; fencing tokens for mutual exclusion; leader as SPOF (informed by: understanding-distributed-systems)
  • Load Balancing — DNS LB, L4 (transport), L7 (application), service discovery, health checks, power of two choices, sidecar as client-side LB; stateless services as prerequisite for scale-out (informed by: understanding-distributed-systems, foundations-of-scalable-systems)
  • Logical Clocks — Physical clock failures (drift, NTP jumps, monotonic); happened-before relation; Lamport clocks (total order); vector clocks (partial order, concurrent detection) (informed by: understanding-distributed-systems)
  • Partitioning — Key range, hash, consistent hashing, secondary indexes (local/global), rebalancing strategies, request routing; cross-partition complexity costs (informed by: designing-data-intensive-applications, understanding-distributed-systems)
  • Queueing Theory — Little's Law (L=λW), utilisation curves (W=S/(1−ρ)) and hyperbolic response-time growth, tail latency amplification in fan-out designs, percentile arithmetic (averages lie; can't average percentiles; t-digest/HdrHistogram), queues in series, thread pools as queueing systems; practical heuristics for capacity and tuning (informed by: foundations-of-scalable-systems, designing-data-intensive-applications, release-it, site-reliability-engineering, understanding-distributed-systems)
  • Rate Limiting — Load shedding (503, priority/age ordering), load leveling (async channel + auto-scaling), rate limiting (sliding window buckets, distributed atomic increment, fail-open), constant work pattern (periodic full-state dump, antifragile, self-healing) (informed by: understanding-distributed-systems)
  • Replication — State machine replication (Raft), chain replication (head/tail topology, failure modes, data/control plane split), leader-follower, Dynamo-style; replication lag anomalies; multi-leader conflict resolution (informed by: understanding-distributed-systems, designing-data-intensive-applications)
  • Scalability — definition; replication vs optimization strategies; scale up vs scale out; stateless services requirement; Amdahl's Law; hyperscale; quality attribute trade-offs (performance, availability, security, manageability); architecture evolution pattern (informed by: foundations-of-scalable-systems)
  • Serverless — serverless model (pay-per-invocation, managed autoscaling); cold start by runtime; GAE autoscaling parameters; AWS Lambda (freeze/thaw, provisioned/reserved concurrency, burst limits); parameter study methodology; vendor lock-in (informed by: foundations-of-scalable-systems)
  • System Models — Link models (fair-loss/reliable/authenticated), process failure models (Byzantine/crash-recovery/crash-stop), timing models (sync/async/partial sync); default assumptions (informed by: understanding-distributed-systems)
  • Tls — TLS encryption (asymmetric key exchange + symmetric data), authentication (certificate chain, root CA), integrity (HMAC), handshake, certificate expiry risk (informed by: understanding-distributed-systems)

Operations

  • Availability — Uptime/downtime definition; the nines table (90%–99.999%); techniques for high availability; dependency chaining effects; design-for-production philosophy; ROI of availability investment; MTBF/MTTR/RPO/RTO measurement framework; tyranny of the nines antipattern; Allspaw: MTTR > MTBF; SRE: 100% is always the wrong target (informed by: understanding-distributed-systems, release-it, software-architecture-metrics, site-reliability-engineering)
  • Chaos Engineering — definition, prerequisites, experiment design, injection types (Chaos Monkey/Latency Monkey/FIT), targeting strategy, automation and moderation, disaster simulations; theoretical foundations (drift into failure, regulator paradox, antifragility); complex systems foundations (accidental vs essential complexity, emergent failures, composability of safety); Netflix origin story; Chaos Maturity Model (informed by: release-it, chaos-engineering)
  • Common Failure Causes — failure taxonomy: hardware, incorrect error handling (2014 study), configuration changes, SPOFs, gray failures, resource leaks, cascading/metastable failures; risk = probability × impact; airline/Black Friday/"Trampled" case studies; building-for-tests vs building-for-production; GC death spiral, queue management (LIFO/CoDel), deadline propagation, latency vs capacity cache (informed by: understanding-distributed-systems, release-it, site-reliability-engineering)
  • Error Budgets — error budget = 1 − SLO target; resolves dev/ops conflict by aligning incentives; budget exhaustion triggers release freeze; burn rate alerting; 100% is wrong target argument (informed by: site-reliability-engineering)
  • Manageability — Dynamic configuration (config store, runtime re-read); feature flags (progressive rollout, A/B testing, kill switch, deployment-release decoupling); operational triad: monitor → observe → manage (informed by: understanding-distributed-systems)
  • Monitoring — Black-box vs white-box monitoring; metrics and pre-aggregation; SLIs/SLOs; burn rate alerting; three-layer ML monitoring taxonomy (golden signals/generic ML signals/domain-specific quality); four actuals cases; drift detection (PSI, KL divergence, Wasserstein); ML SLOs and privacy in monitoring (informed by: understanding-distributed-systems, release-it, site-reliability-engineering, reliable-machine-learning)
  • Observability — Observability as superset of monitoring; three telemetry sources (metrics, logs, traces); structured event logs (one event per work unit, request ID, sampling); distributed tracing (trace ID propagation, spans, Zipkin/X-Ray); metrics and traces as derived views of event logs; Newman: log aggregation first, correlation IDs, Jaeger, synthetic transactions (informed by: understanding-distributed-systems, monolith-to-microservices)
  • Site Reliability Engineering — SRE as discipline: dev/ops conflict; error budgets; toil cap (50%); SLO-driven alerting; blameless postmortems; SRE vs DevOps distinction; applicability outside Google (informed by: site-reliability-engineering)
  • Automation — Automation vs autonomy; 5-level hierarchy (manual → autonomous); safety properties (rate limiting, idempotency); MySQL on Borg case study (informed by: site-reliability-engineering)
  • Incident Management — Hypothetico-deductive troubleshooting; ICS roles; "only Ops modifies"; blameless postmortems; outage tracking; ML incident response (harder detection, broader scope, fuzzy timeline, RPO/RTO for ML) (informed by: site-reliability-engineering, reliable-machine-learning)
  • Testing For Reliability — Zero-MTTR via pre-production testing; traditional test hierarchy; production tests (config tests, stress tests, canary); production probes; barrier defence pattern; configuration file risk management (informed by: site-reliability-engineering)
  • Data Integrity — Data integrity vs availability distinction; replication ≠ recoverability; failure mode matrix (cause × scope × rate); defence in depth: soft deletion / tiered backups / out-of-band validation; point-in-time recovery; continuously test restore; Gmail and Google Music case studies (informed by: site-reliability-engineering)

Implementation Patterns

  • Mvc Web Presentation — MVC pattern; Page Controller vs Front Controller; Template/Transform/Two Step View; Application Controller (informed by: patterns-of-enterprise-application-architecture)
  • Bulkhead — Resource partitioning, shuffle sharding, cellular architecture (informed by: understanding-distributed-systems)
  • Circuit Breaker — Closed/open/half-open state machine for downstream resiliency (informed by: understanding-distributed-systems)
  • Timeout — Bounding wait time on every blocking call; sizing by P99.9; absent-timeout gotchas; relationship to circuit breaker and retry (informed by: release-it, understanding-distributed-systems)
  • Retry — Transient failure recovery; exponential backoff with jitter; retry amplification in chains; idempotency prerequisite; retry queues (informed by: understanding-distributed-systems, release-it)
  • Outbox Pattern — Atomic write + publish without 2PC; relay process; CDC; data liberation patterns; DDD: two wrong approaches + correct approach; NoSQL embedding; pull vs push relay (informed by: understanding-distributed-systems, building-event-driven-microservices, learning-domain-driven-design)
  • Saga — 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 (informed by: understanding-distributed-systems, fundamentals-of-software-architecture, software-architecture-the-hard-parts, building-event-driven-microservices, learning-domain-driven-design, monolith-to-microservices)
  • Strangler Fig — Incremental migration pattern: identify → implement → redirect via proxy; HTTP/FTP/message variants; UI composition (page, widget, micro frontends); deployment ≠ release; feature freeze (informed by: monolith-to-microservices)
  • Branch By Abstraction — Migration for deeply embedded capabilities: 5 steps; feature toggles; verify variant with automatic fallback (informed by: monolith-to-microservices)
  • Parallel Run — Correctness verification: both implementations run per request; old result returned; GitHub Scientist; dark launching vs canary vs parallel run; progressive delivery (informed by: monolith-to-microservices)
  • Progressive Delivery — Release in stages exposing change to controlled subsets; deployment vs release decoupling; canary/blue-green/ring/dark-launch/parallel-run/feature-flag spectrum; SRE order-of-fault model; "roll back first, diagnose second"; prerequisites and anti-patterns (informed by: site-reliability-engineering, release-it, mastering-api-architecture, building-evolutionary-architectures, monolith-to-microservices, accelerate)
  • Sidecar Service Mesh — 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 (informed by: understanding-distributed-systems, mastering-api-architecture, software-architecture-the-hard-parts, building-event-driven-microservices)
  • Anti Corruption Layer — 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 (informed by: domain-driven-design, learning-domain-driven-design, monolith-to-microservices, building-evolutionary-architectures)
  • Context Map — 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 (informed by: domain-driven-design, learning-domain-driven-design)
  • Business Logic Patterns — Four-pattern spectrum: transaction script, active record, domain model, event-sourced domain model; subdomain-to-pattern mapping; transaction script failure modes; full tactical decision tree (pattern→architecture→testing strategy); migration paths between patterns (informed by: learning-domain-driven-design)
  • Domain Model — DDD tactical pattern for core subdomain business logic: value objects (immutable, identified by values), entities, aggregates (consistency boundary, one-per-transaction rule, aggregate root, OCC), domain events, domain services; Evans elaborations on associations, entity identity, context-dependent entity/VO classification, service partitioning, modules as model elements (informed by: learning-domain-driven-design, domain-driven-design)
  • Repository — Evans' REPOSITORY pattern: in-memory collection illusion over aggregate roots; hides persistence technology; only for roots needing direct access; transaction control left to client; factory/repository complementarity (informed by: domain-driven-design)
  • Specification — predicate VALUE OBJECT for expressing domain rules: three uses (validation, selection/querying, building to order); composite Specification with AND/OR/NOT; subsumption; integrates with REPOSITORY via selectSatisfying() (informed by: domain-driven-design)

Databases

  • Object Relational Mapping — O/R mapping architectural patterns (Table Data Gateway, Row Data Gateway, Active Record, Data Mapper); behavioural patterns (Unit of Work, Identity Map, Lazy Load); structural mapping; inheritance strategies (Single/Class/Concrete Table Inheritance) (informed by: patterns-of-enterprise-application-architecture)
  • Storage Engines — Hash indexes, SSTables/LSM-Trees, B-Trees, OLTP vs OLAP, column-oriented storage, materialized aggregates (informed by: designing-data-intensive-applications)
  • Data Models — Relational, document, graph models; schema-on-read vs write; SQL, Cypher, SPARQL, Datalog query languages (informed by: designing-data-intensive-applications)
  • Encoding And Evolution — JSON/XML, Thrift, Protobuf, Avro; schema evolution; forward/backward compatibility; dataflow modes (informed by: designing-data-intensive-applications)
  • Transactions — ACID, isolation levels (dirty reads, read skew, write skew, phantoms), MVCC, SSI, actual serial execution, 2PL (informed by: designing-data-intensive-applications, understanding-distributed-systems)

Streams

  • Batch Processing — Unix philosophy, MapReduce, join algorithms, Hadoop vs MPP, Spark/Flink dataflow engines, Pregel graph processing (informed by: designing-data-intensive-applications)
  • Stream Processing — Log-based brokers (Kafka), stateless topology primitives, partition assignment, windowing, late event strategies, watermarks vs stream time, reprocessing, state stores (internal/external, changelog, hot replicas), effectively once processing, heavyweight vs lightweight framework comparison, stream joins, exactly-once fault tolerance; Kafka production mechanics: producer batching (acks/idempotence), consumer commit semantics, semantic partitioning, consumer groups, ISR (informed by: designing-data-intensive-applications, building-event-driven-microservices, foundations-of-scalable-systems)
  • Event Sourcing Cqrs — CDC, event sourcing, CQRS, immutability, write/read path, correctness without coordination; DDD: CQRS sync/async projections, architectural slices, event-sourced domain model four-step cycle; Fowler's four-way event taxonomy (notification/state-transfer/event-sourcing/CQRS) (informed by: designing-data-intensive-applications, learning-domain-driven-design, release-it)
  • Change Data Capture — Observing DB changes as event stream; log-based (Debezium, WAL/binlog/oplog), trigger-based, query-based mechanisms; CDC vs event sourcing; dual-write problem solved by outbox + CDC; data liberation patterns; strangler migration; schema coupling; log-compacted topics for bootstrap; backpressure on consumers (informed by: designing-data-intensive-applications, building-event-driven-microservices, monolith-to-microservices, software-architecture-the-hard-parts)

Reference

  • Technology Glossary — Short reference entries for tools: gateways, meshes, testing, observability, identity, databases (Redis Cluster, MongoDB, DynamoDB) (informed by: mastering-api-architecture, understanding-distributed-systems, fundamentals-of-software-architecture, foundations-of-scalable-systems)

Comparisons

  • Architecture Styles Comparison — All 8 architecture styles rated side by side; decision guide; monolith vs understanding-distributed-systems; partitioning type (informed by: fundamentals-of-software-architecture)
  • Orchestration Vs Choreography — Decision guide: when to use a central coordinator vs event-driven choreography; team-ownership heuristic; God Orchestrator anti-pattern; workflow state management options (informed by: understanding-distributed-systems, software-architecture-the-hard-parts, building-event-driven-microservices, learning-domain-driven-design, monolith-to-microservices)
  • Api Protocol Selection — REST vs gRPC vs GraphQL: decision table by traffic type; trade-off analysis across caching, schema, streaming, browser support, evolution; mixing protocols; chatty API anti-pattern (informed by: mastering-api-architecture, understanding-distributed-systems, foundations-of-scalable-systems)
  • Decomposition Strategy — 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 (informed by: fundamentals-of-software-architecture, monolith-to-microservices, software-architecture-the-hard-parts, building-evolutionary-architectures, team-topologies, learning-domain-driven-design)
  • Consistency Model Selection — When to use linearizability vs causal vs eventual consistency; timeliness vs integrity distinction; decision guide by scenario (locks, balances, feeds, shopping carts, multi-region); read routing as the practical knob; CAP trap warning (informed by: designing-data-intensive-applications, understanding-distributed-systems, foundations-of-scalable-systems)
  • Sync Vs Async Communication — When to use synchronous vs asynchronous communication; temporal coupling as the core distinction; availability chaining risk; async concerns (idempotency, ordering, correlation, observability); mixed model (sync north-south, async east-west); decision guide (informed by: enterprise-integration-patterns, monolith-to-microservices, software-architecture-the-hard-parts, building-event-driven-microservices, understanding-distributed-systems, release-it)
  • Build Vs Buy — Build vs buy vs open-source decision framework; subdomain type as the primary analytical tool (core → build, generic → buy/adopt, supporting → build simple); hidden costs of buying; platform team as internal build-once option; sourcing reversals as subdomain types evolve (informed by: learning-domain-driven-design, domain-driven-design, software-architecture-the-hard-parts, building-evolutionary-architectures, team-topologies)
  • Stability Pattern Selection — Which stability pattern when; selection decision tree (outgoing call, incoming request, internal pipeline, system edge, automation, resource pooling); pattern × antipattern matrix; composition order (timeout first, then bulkhead, then breaker, then retry, etc.); anti-patterns of pattern composition (informed by: release-it, understanding-distributed-systems, foundations-of-scalable-systems, site-reliability-engineering, chaos-engineering)
  • Performance And Capacity — Symptom → diagnosis → action playbook; three analytical lenses (Little's Law, utilisation curve, percentile arithmetic); capacity planning workflow; antipatterns (sizing for average, running at high utilisation, unbounded queues); when performance tuning doesn't apply (informed by: foundations-of-scalable-systems, designing-data-intensive-applications, release-it, site-reliability-engineering, understanding-distributed-systems)
  • Migration Pattern Selection — Decision tree: where's the seam, is correctness the dominant risk, granularity, duration, parallel-run cost; pattern composition (service extraction, embedded capability extraction, database split, platform migration); database decomposition patterns; rollback as a feature (informed by: monolith-to-microservices, building-evolutionary-architectures, mastering-api-architecture, release-it)
  • Cost Vs Availability — Nines table with money attached; conversion via downtime cost; investment cost per nine; where each nine is earned; antipatterns (tyranny of the nines, MTBF without MTTR, redundancy without isolation); architectural choices that make availability cheap or expensive (informed by: release-it, site-reliability-engineering, understanding-distributed-systems, foundations-of-scalable-systems, software-architecture-metrics)

Sources

Authors

  • Adam Bellemare — Author of Building Event-Driven Microservices; event-driven architecture specialist; event schema design and data liberation
  • Vlad Khononov — Author of Learning Domain-Driven Design; DDD practitioner and educator; strategic and tactical DDD, EventStorming
  • Daniel Bryant — Co-author of Mastering API Architecture; Principal Technologist at Datawire; security and gateway expert
  • James Gough — Co-author of Mastering API Architecture; API-first and contract testing specialist
  • Mark Richards — Author of Fundamentals of Software Architecture (with Ford), Software Architecture Patterns, Software Architecture: The Hard Parts (with Ford, Sadalage, Dehghani)
  • Pramod Sadalage — Co-author of Software Architecture: The Hard Parts; data architect at ThoughtWorks; evolutionary database design and NoSQL specialist
  • Zhamak Dehghani — Co-author of Software Architecture: The Hard Parts; creator of Data Mesh; analytical data and domain data ownership advocate
  • Matthew Auburn — Co-author of Mastering API Architecture; cloud migration and deployment strategy specialist
  • Neal Ford — Author of Fundamentals of Software Architecture (with Richards), Building Evolutionary Architectures, Software Architecture: The Hard Parts (with Richards, Sadalage, Dehghani); contributing author Software Architecture Metrics ch. 8 (metrics → engineering, zero-day fitness function, checklist manifesto framing)
  • Patrick Kua — Co-author of Building Evolutionary Architectures; technical leadership and engineering culture specialist
  • Rebecca Parsons — Co-author of Building Evolutionary Architectures; ThoughtWorks CTO; distributed systems and evolutionary computation background
  • Martin Kleppmann — Author of Designing Data-Intensive Applications; distributed systems researcher at Cambridge; CRDT and local-first software advocate
  • Eric Evans — Author of Domain-Driven Design (2003); originator of DDD vocabulary (ubiquitous language, bounded contexts, aggregates, strategic design)
  • Sam Newman — Author of Monolith to Microservices and Building Microservices; independent deployability, migration planning, monolith decomposition
  • Roberto Vitillo — Author of Understanding Distributed Systems
  • Matthew Skelton — Co-author of Team Topologies; co-creator of Team Topologies model; fast flow and organisational design specialist
  • Manuel Pais — Co-author of Team Topologies; DevOps and platform engineering consultant; team interaction and organisational sensing specialist
  • Gregor Hohpe — Co-author of Enterprise Integration Patterns; enterprise messaging and integration architect; ESB and MOM specialist
  • Bobby Woolf — Co-author of Enterprise Integration Patterns; messaging middleware and design patterns practitioner
  • Martin Fowler — Author of Patterns of Enterprise Application Architecture; ThoughtWorks Chief Scientist; coined Transaction Script, Domain Model, Active Record, Data Mapper, Repository, Service Layer
  • Michael Nygard — Author of Release It!; stability patterns practitioner; coined Circuit Breaker, Bulkhead, Timeout in the software context; design-for-production advocate
  • Ian Gorton — Author of Foundations of Scalable Systems; distributed systems architect; scalability measurement and empirical architecture
  • Andrew Harmel Law — Contributing author Software Architecture Metrics ch. 1; DORA four key metrics practitioner; delivery transformation consultant
  • Rene Weiss — Contributing author Software Architecture Metrics ch. 2; fitness function testing pyramid; architectural verification frameworks
  • Dave Farley — Contributing author Software Architecture Metrics ch. 3; co-author of Continuous Delivery; testability and deployability as architectural drivers; TDD as design discipline
  • Carola Lilienthal — Contributing author Software Architecture Metrics ch. 4; developer of the Modularity Maturity Index (MMI); empirical architecture quality measurement grounded in cognitive science
  • Christian Ciceri — Editor of Software Architecture Metrics; contributing author ch. 5; private build antipattern remediation; trunk stability as architectural prerequisite
  • Joao Rosa — Contributing author Software Architecture Metrics ch. 6; sociotechnical architecture; KPI Value Tree; Big Picture EventStorming for architectural strategy
  • Eoin Woods — Contributing author Software Architecture Metrics ch. 7; co-author of Continuous Architecture in Practice; quality attribute measurement framework; MTTR > MTBF; RPO/RTO
  • Alexander Von Zitzewitz — Contributing author Software Architecture Metrics ch. 9; creator of Sonargraph; structural metrics (Propagation Cost, Relative Cyclicity, SDI, Maintainability Level, LCOM4, Component Rank); six golden rules; structural erosion as default outcome
  • Michael Keeling — Contributing author Software Architecture Metrics ch. 10; author of Design It!; Goal-Question-Metric (GQM) framework; measurement as alignment and coaching tool
  • John Ousterhout — Author of A Philosophy of Software Design; Stanford CS professor; creator of Tcl and Raft; deep modules, information hiding, and complexity management advocate
  • Nicole Forsgren — Co-author of Accelerate; PhD in MIS; DORA research programme; psychometric and statistical rigour applied to DevOps; four key metrics originator
  • Jez Humble — Co-author of Accelerate; co-author of Continuous Delivery; CI/CD, Lean, DevOps practitioner; DORA research programme
  • Betsy Beyer — Co-editor of Site Reliability Engineering; Google Technical Writer for SRE; cultural and documentary aspects of reliability
  • Chris Jones — Co-editor of Site Reliability Engineering; Google SRE on App Engine; platform-service and capacity-planning perspective
  • Jennifer Petoff — Co-editor of Site Reliability Engineering; Google SRE Programme Manager; training, on-call rotation design, postmortem culture
  • Niall Richard Murphy — Co-editor of Site Reliability Engineering; co-author of Reliable Machine Learning; Google SRE in Dublin; incident response, federation, SRE applied to ML systems
  • Benjamin Treynor Sloss — Wrote Ch. 1 of Site Reliability Engineering; VP Engineering at Google; originator of the term "Site Reliability Engineering"; creator of the error budget model
  • Gene Kim — Co-author of Accelerate; founder and CTO of Tripwire; co-author of The Phoenix Project and The DevOps Handbook; high-performing technology organisation researcher
  • Casey Rosenthal — Co-author of Chaos Engineering; built and managed Netflix's Chaos Engineering team; co-creator of the Principles of Chaos Engineering
  • Nora Jones — Co-author of Chaos Engineering; Netflix Chaos Engineering team; safety science and sociotechnical systems perspective
  • Chip Huyen — Author of AI Engineering; Stanford lecturer (CS 329S: ML Systems Design); ML systems and AI engineering specialist
  • Cathy Chen — Co-author of Reliable Machine Learning; ML systems practitioner; SRE approach to ML production operations
  • Kranti Parisa — Co-author of Reliable Machine Learning; ML engineering practitioner; data management and fairness
  • D Sculley — Co-author of Reliable Machine Learning; Google research scientist; coined "hidden technical debt in machine learning systems"
  • Todd Underwood — Co-author of Reliable Machine Learning; SRE practitioner; applying SRE discipline to ML training and serving pipelines