• 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
    • 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
    • Architecture Styles
    On this page
    category

    Architecture Styles

    The named styles you will actually meet — layered, hexagonal, microservices, event-driven, CQRS, serverless, per-user instances, and the data platform — and the bill each one hands you.

    layers

    Layered (N-Tier): The Style Nobody Chose

    Controller, service, repository. The most-deployed architecture in the world, the least written about, and the rules that keep it from …

    hexagon

    Ports and Adapters (Hexagonal)

    One rule — dependencies point inward — and a test for whether you should be paying the indirection tax at all.

    lan

    Microservices: The Itemised Bill

    Whether to split is covered elsewhere. This is what the style demands as a package, and what you get if you pay only part of it.

    bolt

    Event-Driven: When the Broker Is the Backbone

    Choreography scales in the writing and fails in the reading. What changes when the log becomes the centre of your system.

    alt_route

    CQRS and Read Models

    Separating reads from writes is a five-rung ladder. Most teams need rung two and start at rung five.

    cloud_queue

    Serverless and Managed Services

    You did not remove the operational burden, you traded it for a different one — IAM, limits, and a cost curve that inverts.

    apps

    Per-User Instances Behind Capability Gateways

    Cloudflare OS gives every user a private, sandboxed copy of each app and routes all outside access through per-service brokers. What that …

    database

    Data Platform Styles: Lakehouse and What Sits Around It

    Six styles that are genuinely alternatives, two that are not alternatives to anything, and the one decision everybody forgets is two …


    © 2026 Architecture Field Notes. Built with Lotus Docs