Foreword
Architecting the Runtime
Working Effectively with Modular Monoliths
- The problem this chapter solves
- What you need
- The architecture
- The plugin lifecycle, step by step
- Event-driven communication between plugins
- Dynamic navigation from plugin metadata
- Operational baseline
- When to reach for this pattern
- Open risks (stated plainly)
- Evaluation status
- Where to look
Reversible Plugin Execution — Keeping the Microservices Option Open
- The problem this chapter solves
- The library architecture
- Plugin identity as value types, not strings
- Isolated loading: the collectible
AssemblyLoadContext - Typed execution
- The security validation pipeline
- Testing discipline: what 48 tests actually prove
- Hybrid execution: v2.1.0 and the containerized mode
- The design trade, stated plainly
- When to reach for this pattern
- Open risks (stated plainly)
- Evaluation status
- Where to look
Managing Extension Points Without Over-Engineering
- The problem
- What you need
- The decision: what earns a seam
- A working taxonomy
- Designing the contract
- Team cooperation mechanics
- The complexity ledger and the collapse discipline
- Safety at the boundary
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Bounded Contexts as Independently Versioned Packages
- The problem this chapter solves
- The thesis
- Where the idea comes from
- The system (shipped)
- The DDD reading (design analysis)
- Limiting required domain knowledge
- When to reach for this pattern
- Open risks (stated plainly)
- Evaluation status
- Conclusion
- Where to look
Engineering Multitenant Isolation
- The problem this chapter solves
- What you need
- Layer 1 — Application-scoped tenancy
- Layer 2 — Database-enforced isolation (row-level security)
- Layer 3 — Tenant-bound cryptography (envelope encryption)
- Resolving and provisioning tenants
- When to reach for this pattern
- Open risks (stated plainly)
- Evaluation status
- Where to look
Reliable Event-Driven Integration Across Boundaries
- The problem this chapter solves
- What you need
- The transactional outbox
- The idempotent consumer
- The dead-letter route — failure as a designed path
- Event schemas that evolve
- Backpressure and queue depth as operational signals
- When to reach for this pattern
- Open risks (stated plainly)
- Evaluation status
- Where to look
Strangler-Fig Migration and Retirement Engineering
- The problem this chapter solves
- What you need
- Routing seams and anti-corruption layers
- Dual-running with verification
- Retirement engineering: the exit door designed on the way in
- When the strangler stops being worth it
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Languages and Agents
Building and Working with Domain-Specific Languages
- The problem this chapter solves
- The workbench architecture
- Defining a language: the grammar file
- Grammar inheritance: language families and version management
- Embedded languages: context switching
- Grammars as data: the grammar library
- The case studies, labeled honestly
- Limitations (stated in the source, kept here)
- When to reach for this pattern
- Evaluation status
- License note — read before adopting
- Where to look
SpecTree — Method for Improved Human–Code-Agent Handovers
- 1. Why SpecTree exists
- 2. Core concepts (carried forward from SDD)
- 3. The handover model
- 4. Trigger rules — the operational contract
- 5. The pull-request lifecycle
- 6. Environments: where humans meet the tree
- 7. Bootstrapping the tree from existing code (H5)
- 8. Guardrails and risks
- 9. Adoption path
- 10. Evaluation status
- Appendix — lineage from the earlier documents
- Works consulted — the intent-centric review literature
The Agentic Kill Switch and LLM Firewall at Runtime
- The problem this chapter solves
- What you need
- The LLM firewall: default-deny at the tool boundary
- Kill-switch mechanics: circuit breakers and staged permission rollback
- Re-entry gates and the signed restoration record
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Engineering Self-Evolving Code with Security Guardrails
- The problem this chapter solves
- What you need
- The evolution loop: chromosomes of source, informed mutation, computed fitness
- The security guardrails: AST facts, Rego policies, unload, and budgets
- Adversarial review and local-first model routing
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Specification-Driven Test Generation and Predictive Regression
- The problem this chapter solves
- What you need
- The pipeline: contracts in, test proposals out
- Event-driven execution and failure clustering
- Predictive regression: change impact, drift triage, and fuzzing
- Coverage as a risk signal — and the builds that catch rot
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Collaborative Domain Discovery on a Shared Canvas
- The problem
- What you need
- A typed canvas, not a digital wall
- Permissioned collaboration: who may move what
- From storm to specification
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Citizen Development on Specification Rails
- The problem
- What you need
- The specification rail: a virtual structure over any codebase
- The draft-PR pipeline: from edit to reviewed change
- Governance as code — and the honesty ledger
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Grounding GenAI in Organizational Knowledge
- The problem
- What you need
- The grounding stack
- From vector search to knowledge graphs
- Session context: the other half of grounding
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Bounded Agent Execution Through a Micro-Action Vocabulary
- The problem
- What you need
- The action contract: anatomy of a micro-action
- From intent to invocation
- Execution and isolation
- Trusting work that leaves the box
- The vocabulary as guardrail
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
LLM and Agent Evaluation Harnesses
- The problem
- What you need
- What an eval harness actually is
- Retrieval eval: the grounding chapter’s required harness, built
- Generation eval: faithfulness, refusal correctness, and the benchmark trap
- Agent and task eval: from structural fitness to semantic outcomes
- Eval as CI: gating the things that change
- Honest measurement discipline
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Old Bias, New Expression — Machine Bias in the GenAI Era
- The problem
- A way of seeing: the old taxonomy, re-expressed
- The corpus you choose is the bias you ship
- Bias as an eval dimension, not a vibe
- Agents close the loop at machine speed
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
- Works cited
Engineering the Human Decision — UX and Psychology for Real Human-in-the-Loop GenAI
- The problem
- The psychology that defeats naive loops
- The decision inventory: what is the human actually deciding?
- UX mechanics that manufacture real decisions
- The worked example: the book’s own spine
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
- Works cited
Deterministic Chains — An Operations Agent That Earns Production Access
- Companion diagrams (editable drawio)
- What you need
- 1. The position: non-determinism is an operational property
- 2. Chains as records, test as the only first environment
- 3. Promotion is earned, then approved
- 4. Irreversible is never automated
- 5. The operator is small, dumb, and auditable
- 6. Takeover, not reduction
- 7. Anti-patterns, honestly
- 8. When to reach for this pattern
- 9. Open risks
- 10. Checklist
- 11. Evaluation status
- 12. Works cited
Operating Distributed Systems
Separating Network Responsibilities in Distributed Systems
- Companion diagrams (editable drawio)
- 1. The first distinction: which plane is executing right now?
- 2. The second distinction: which direction may the traffic flow?
- 3. The third distinction: what happens over time — maintenance without severance
- 4. The fourth distinction: how far does administrative reach extend?
- 5. The fifth distinction: how deep is the enforcement point?
- 6. Using the lens honestly: where the naive reading goes wrong
- 7. Working guidance: five questions, five rules
- Works cited
Thinking Inside the Network — Microsegmentation as Code
- Companion diagrams (editable drawio)
- 1. What microsegmentation actually is — and what it is not
- 2. The core principle: policy follows identity, not topology
- 3. The five enforcement layers
- 4. Git tooling in layers
- 5. The toolchain: who owns what
- 6. eBPF: enforcement inside the network
- 7. Day 1: admitting a new segment
- 8. Day 2: operating segments with IaC
- 9. One methodology, three renders: Windows, Linux, Kubernetes
- 10. Synthesis and actionable guidance
- Evaluation status
- Works cited
Segmenting the Estate — Enclaves and Zero Trust at Scale
- 1. The estate problem: when the network diagram stops fitting on one page
- 2. The vocabulary: estate, enclave, seam, ring
- 3. Rings, not walls: defense in depth that zero trust can live with
- 4. The model reused: responsibility planes at estate scale
- 5. Cross-cloud enclaves: one estate policy, many fabrics
- 6. Cross-company enclaves: partners, vendors, and the seam you do not own
- 7. Local and OT systems: the estate’s oldest enclaves
- 8. Seams are the product
- 9. The estate in Git
- 10. Day 2 at estate scale
- 11. One methodology, many renders
- 12. Synthesis
- Evaluation status
- Works cited
Secure Developer Ingress Through a Hardened Multitenant Reverse Proxy
- The problem this chapter solves
- What you need
- The platform: one hardened ingress, many named users
- Authorization as the seam: per-user allowed-domain patterns
- Operations: renditions, SLOs, and the honest limits
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Application Identity, Authentication, and Secrets
- The problem
- What you need
- Authentication engineering
- Authorization as data
- Service identity and the tenancy seam
- Secrets lifecycle: engineered, not exported
- Auditing identity decisions
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Declaring Runtime Intent — The Software Bill of Behavior
- Companion diagrams (editable drawio)
- 1. What an SBoB is — and what it is not
- 2. The contract, section by section
- 3. From contract to enforcement points: one transpilation, three stages
- 4. Collection: what each platform can honestly see
- 5. Day 1: earning the contract
- 6. Day 2: the drift triage loop
- 7. Worked example: the SBoB transpiler — three stages, one transpilation (DevelApp-ai)
- 8. When to reach for this pattern
- 9. Open risks
- 10. Checklist
- 11. Evaluation status
- 12. Works cited
Observed Behavior to Declared Intent — Bootstrapping an SBoB from Telemetry
- Companion diagrams (editable drawio)
- 1. The fidelity ladder: what may contribute an entry, and in what role
- 2. The derivation pipeline
- 3. Odd-behavior disposition: what happens to the strange entry
- 4. Windowing honestly: how long you must watch
- 5. The closed loop: drift is the fallback for what the window missed
- 6. When to reach for this pattern
- 7. Open risks
- 8. Checklist
- 9. Evaluation status
- 10. Works cited
Observability Engineering: The Telemetry Substrate
- The problem
- What you need
- The three signals and their contracts
- Instrumentation as code and context propagation
- Cardinality as a budget
- SLOs as measurement, not aspiration
- The hand-off seams
- Provenance, retention, and what the substrate costs
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Storage and State at Scale
- The problem
- What you need
- Cache engineering: invalidation as a contract
- Replication: lag as a consistency surface
- Partitioning: keys chosen by access pattern
- Consistency as a spectrum, used deliberately
- Connection pooling: the state-isolation hazard
- The capacity model: will it fit?
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Resilience, Capacity, and Disaster Recovery Drills
- The problem
- What you need
- The claim inventory: rehearsed versus asserted
- Backup as rehearsed engineering
- Chaos drills as scheduled practice, not stunts
- Capacity engineering: headroom bands, not surprises
- Disaster recovery as a written, tested plan
- SLO drills: closing the loop the ingress chapter opened
- Resilience economics: what redundancy actually costs
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Owning the Data
Enforceable Data Contracts
- The problem this chapter solves
- What you need
- The contract as an executable artifact
- Compatibility gates in CI
- CDC pipelines with quarantine
- Drift detection and the problem register
- When to reach for this pattern
- Open risks (stated plainly)
- Evaluation status
- Where to look
Evolving Data Schemas Without Downtime
- The problem
- What you need
- Expand: additive change as the default discipline
- Migration as artifact: schema and code move together
- The dual-write window and measurement-based cutover
- Backfill engineering: why naive UPDATE loops take production down
- Composing with contract compatibility gates
- Contract: the removal step
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Engineering the Right to Be Forgotten
- The problem this chapter solves
- What you need
- Deletion fan-out: enumerate the copies before deleting any of them
- Scheduled deletion and on-request erasure are one machinery
- Cryptographic erasure: destroy the key instead of chasing the bytes
- Deletion evidence: certificates, sampling, reconciliation
- The AI wrinkle: regeneration and model memory
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Immutable Ledgers — Verification, Trading, and Certification
- The problem this chapter solves
- What you need
- What a blockchain actually is — and is not
- When a ledger earns its place
- Verification for open source — anchoring behavior contracts
- Trading between distrusting parties
- Certificates anyone can verify
- The costs, stated loudly
- Changing an immutable system — the upgrade methodology
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Building a Streaming and Batch Data Platform
- The problem
- What you need
- CDC as the spine
- The repair and replay loop
- Stream versus batch: a tradeoff, not a fashion choice
- Delivery semantics, honestly
- The lakehouse pattern at engineering level
- The contract seam
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Data Quality, Lineage, and Cataloging
- The problem
- What you need
- Quality as gates: four families and a ladder
- The self-reporting pipeline as pattern precedent
- Lineage as a generated artifact
- The catalog: three fields, answerable questions
- Bad data is an incident
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Operating and Improving
Release Engineering and Progressive Delivery
- The problem
- What you need
- Artifact provenance: one build, promoted never rebuilt
- Environment promotion as a contract
- Progressive delivery mechanics
- Release as code
- Which changes need a planned release
- Rollback as first-class
- The DORA seam
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Incident-to-Action Engineering
- The problem this chapter solves
- What you need
- Severity before the incident; an alert creates a record
- Runbooks as code and the escalation clock
- Postmortems whose actions actually land
- Self-reporting systems: CI that files its own diagnostics
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Building a DORA Metrics Pipeline
- The problem this chapter solves
- What you need
- The four keys from real events
- Making change failure rate well-defined
- Feeding the number onward without making it the target
- The honest caveats
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Compliance as Code
- The problem this chapter solves
- What you need
- The SBOM in CI: what it does and does not prove
- Provenance and pin verification: trust bytes, not intentions
- Policy-as-code checks as pipeline steps
- ADR-as-code: supersede chains a machine can traverse
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Behavior Deltas at the Release Gate — Supply-Chain Security from SBoB Diffs
- Companion diagrams (editable drawio)
- 1. The gate: a semantic diff with weights, not a YAML blob
- 2. Scoring the delta: thresholds that mean something
- 3. Why this catches what SBOM gates cannot
- 4. The review workflow: who signs, what they see
- 5. Anti-patterns, honestly
- 6. When to reach for this pattern
- 7. Open risks
- 8. Checklist
- 9. Evaluation status
- 10. Works cited
Publishing the Contract — SBoB Distribution, Signing, and Visibility
- Companion diagrams (editable drawio)
- 1. Two copies, one contract
- 2. The registry: git as the registry
- 3. Packaging channels: where the profile rides
- 4. Signing: two layers, one identity pin
- 5. Visibility: who may read the declaration
- 6. Anti-patterns, honestly
- 7. When to reach for this pattern
- 8. Open risks
- 9. Checklist
- 10. Evaluation status
- 11. Works cited
Enforcing Software Bills of Behavior
- Companion diagrams (editable drawio)
- 1. The gate: verify the package you are about to run
- 2. Fail-closed canonical parsing: reject, never repair
- 3. Policy as data: the rule set is a configuration object
- 4. The enforcing decorator: deny without invoking the runtime
- 5. The rollout ladder — and the default that protects strangers
- 6. Anti-patterns, honestly
- 7. When to reach for this pattern
- 8. Open risks
- 9. Checklist
- 10. Evaluation status
- 11. Works cited
Deterministic Documentation for Infrastructure Code
- The problem this chapter solves
- What you need
- Rendered from the source of truth
- Decisions as data: MoSCoW, ADRs, and rendered traceability
- The gate: policy-violating pull requests cannot merge
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Automated Code Review at the Pull Request Gate
- The problem this chapter solves
- What you need
- The gate: findings as review actions
- The analyzer fabric: one gate, many surfaces
- Security framing as an aid, not certification
- The trajectory of the pattern: criteria-aware review
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
A Branching Strategy That Earns Its Keep
- The problem this chapter solves
- What you need
- The default: a protected trunk and short-lived branches
- Release branches: earned by the risk matrix, not by the calendar
- Conflict resolution as a designed path
- Traceability: the ledger starts at the merge
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Engineering Cloud Unit Economics
- The problem this chapter solves
- What you need
- The unit-cost metric: instrument the attribution, state the boundaries
- Budgets and anomaly alerts: ±20% as an operational signal
- Showback rate cards: the honest limits of chargeback
- Agentic demand: token burn as a forecastable curve
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Composable Infrastructure Components
The Component Hierarchy — General, Customer, Project
- The problem this chapter solves
- What you need
- Three levels, one dependency direction
- What earns a level
- Platform classes and the operability contract
- Maintainability is the point
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
The Component Package — Signed, Versioned, Attested
- The problem this chapter solves
- What you need
- Package anatomy
- Signing and the three verification points
- Semver at infrastructure scale
- The mini-TDS — partially generated, never hand-copied
- Azure Well-Architected alignment where it does not conflict
- Hierarchy × package = maintainability
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
One Component, Many Fabrics — the Render Matrix
- The problem this chapter solves
- What you need
- The render matrix as a versioned artifact
- Tool honesty per row
- The abstraction boundary: contract to renders
- Workload operability across substrates
- Second-day operations live in other repos
- Coverage reality in the demonstration estate
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Network Components — Segmentation, Enclaves, and Diodes as Building Blocks
- The problem this chapter solves
- What you need
- The network component taxonomy
- Renditions per environment
- Diodes as components — with honesty
- Evidence and promotion as shipped tests
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Policy as Code and Compliance as Components
- The problem this chapter solves
- What you need
- Policy components at every level
- One policy source, N fabric renders
- Compliance as code at component scale
- Company-domain specialization mechanics
- Supply-chain security audits as pipelines
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Securing the Component Supply Chain
- The problem this chapter solves
- What you need
- The threat model, mapped to gates
- DevSecOps in the component pipeline
- Sign everything that ships; verify at every gate
- Company-domain adjustments
- IAM without lock-in — the broker pattern
- Quarantine and kill paths
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look
Baking Images, Patching, and the Component Lifecycle
- The problem this chapter solves
- What you need
- Packer baking as composition
- Patch handling with components
- Pull versus push — the tradeoff, stated
- SBoB enforcement across diodes and enclaves
- The component lifecycle
- Subcontractor deliveries — the non-component boundary
- When to reach for this pattern
- Open risks
- Evaluation status
- Where to look