• Irreversible Decisions
    • Constraints First
    • Coupling and Cohesion in Practice
    • Trade-off Sliders
    • The Boring Baseline
    • Monolith First, Split on Evidence
    • Service Boundaries That Survive Reorgs
    • Synchronous vs Asynchronous Integration
    • API Contracts and Versioning
    • Idempotency and Retries
    • Choosing a Datastore Without Regret
    • Schema Migrations Without Downtime
    • Consistency Models You Actually Need
    • Caching: The Four Questions
    • Event Sourcing and CDC: When It Pays
    • Trunk-Based Development and Branch Reality
    • Pipeline Design: Fast Feedback, Slow Gates
    • Progressive Delivery
    • Build Reproducibility and Artifact Promotion
    • Rollback Is a Feature
    • Kubernetes: What You Sign Up For
    • Infrastructure as Code That Doesn't Drift
    • Environments, Config, and Secrets
    • Multi-Tenancy and Cost Boundaries
    • The Internal Platform as a Product
    • SLOs, Error Budgets, and Saying No
    • Observability: What to Actually Wire
    • Capacity, Load Shedding, and Backpressure
    • Failure Modes: Timeouts, Breakers, Bulkheads
    • Incident Response and Blameless Postmortems
    • Threat Modeling in One Hour
    • Identity, Authentication, Authorisation
    • Secrets and Key Management
    • Supply Chain: Dependencies, SBOM, Signing
    • Least Privilege and Auditability
    • Architecture Decision Records That Get Read
    • Diagrams That Age Well
    • Runbooks and On-Call Docs
    • Design Reviews and RFCs
    • Building a Team Architecture Memory
    • GitHub
  • to navigate
  • to select
  • to close
    • Home
    On this page
      • What this is
      • How to read it
      • Sections
      • A warning
      • What this is
      • How to read it
      • Sections
      • A warning
    home

    Overview

    Practical architecture knowledge for DevOps engineers and developers — the decisions, trade-offs, and failure modes that only show up in production.

    foundation folder

    Foundations

    What architecture actually is once you strip the diagrams away: irreversible decisions, constraints, and coupling.

    schema folder

    System Design in Practice

    Boundaries, contracts, and integration styles that survive contact with a real organisation.

    database folder

    Data and State

    The layer that is hardest to change and easiest to get wrong: storage choice, migrations, consistency, and caching.

    rocket_launch folder

    Delivery and CI/CD

    How code gets from a laptop to production without drama: branching, pipelines, progressive rollout, and rollback.

    cloud folder

    Platform and Infrastructure

    The substrate everything runs on — Kubernetes, IaC, config, tenancy, and the internal platform as a product.

    monitor_heart folder

    Reliability and Operations

    Keeping it up, knowing what up means, and being useful at 3am: SLOs, observability, failure modes, incidents.

    shield folder

    Security by Design

    The parts you cannot bolt on afterwards: threat models, identity boundaries, secrets, supply chain, and least privilege.

    menu_book folder

    Making Knowledge Explicit

    ADRs, diagrams, runbooks, RFCs, and building a team architecture memory that outlives the people who built it.


    © 2026 Architecture Field Notes. Built with Lotus Docs