• 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
    • Case Study: Reviewing a Small Portal Before It Exists
    • Layered (N-Tier): The Style Nobody Chose
    • Ports and Adapters (Hexagonal)
    • Microservices: The Itemised Bill
    • Event-Driven: When the Broker Is the Backbone
    • CQRS and Read Models
    • Serverless and Managed Services
    • Per-User Instances Behind Capability Gateways
    • Data Platform Styles: Lakehouse and What Sits Around It
    • GitHub
  • to navigate
  • to select
  • to close
    • Home
    • Making Knowledge Explicit
    On this page
    menu_book

    Making Knowledge Explicit

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

    history_edu

    Architecture Decision Records That Get Read

    One page, written at the moment of the decision, recording the context and what you rejected. That last part is the whole value.

    account_tree

    Diagrams That Age Well

    Most architecture diagrams are wrong within a month. The fix is fewer diagrams, at deliberate levels of detail, generated where possible.

    menu_book

    Runbooks and On-Call Docs

    Write for a tired, frightened person who did not build this and is being asked to fix it right now.

    reviews

    Design Reviews and RFCs

    Surface disagreement while it is cheap. A review that produces consensus without surfacing objections has failed.

    psychology

    Building a Team Architecture Memory

    The goal is that the system's reasoning survives the people who built it. Nothing else on this site matters if this fails.

    fact_check

    Case Study: Reviewing a Small Portal Before It Exists

    A community portal planned as a slide deck, reviewed three times, and what changed. Most of the risk was in the data model, not the hosting.


    © 2026 Architecture Field Notes. Built with Lotus Docs