Engineering · Systems atlas
The whole stack, drawn.
From the network underneath to the agents on top: cloud foundations, security models, delivery platforms, agent runtimes, knowledge systems and the factory that builds them. Every diagram on this page responds to you. The shapes are real. The specifics that belong to employers, clients and the recipe stay private.
- cloud projects on one connectivity pattern
- 100scloud projects on one connectivity pattern
- connectivity hubs in the reference fabric
- 6connectivity hubs in the reference fabric
- verification gates from truth to production
- 11verification gates from truth to production
- lifecycle states enforced server-side in one application
- 28lifecycle states enforced server-side in one application
- workforce archetypes on one codebase
- 5workforce archetypes on one codebase
- tool domains behind one policy gateway
- 8tool domains behind one policy gateway
00The stack
Seven layers, one discipline.
Each layer exists to make the one above it boring. Pick a layer to see what lives there, then jump to its working diagram.
Agents as bounded workers: a role, a policy, tools exposed over the Model Context Protocol, approval gates for anything consequential, and an audit trail for everything.
- MCP servers
- Tool gateways
- Approval gates
- Structured outputs
- Evaluation harness
- Audit trail
01Cloud foundations
A network a new team joins by declaring intent.
Six hubs around a routing core. Spokes never peer directly; hybrid, service, egress and east-west traffic each take one legible path. Trace a flow.
- On-premises
- Interconnect
- Hybrid hub
- Routing core
- Prod hub
- Workload A
Private links terminate on cloud routers in the hybrid hub. Prefixes are advertised once and learned only where they should be.
Drafted studies
Two sheets from my diagramming work, redrawn with generic labels in place of inventory, addresses and resource identities.
Hybrid connectivity
A hub is a boundary with a job: connect hybrid networks, make routing legible, and keep workload ownership separate from the shared network.
- ↳ Hybrid paths and cloud routing
- ↳ Shared connectivity, separate workloads
- ↳ Private service access
02Security & posture
Stop triaging findings. Read the graph.
A severity list tells you what is wrong with each thing. A model of the estate tells you which wrong things line up into a path to something that matters.
60
findings, sorted by the vendor's severity
0
relationships between them
?
which ones reach anything that matters
Illustrative model · synthetic estate · no vendor output reproduced
03Reliable platforms
Policy before anything is real. Budgets set the pace.
Infrastructure changes are intent until a plan has been computed, checked and approved. After release, a service level objective decides whether the next change ships.
- 01
Intent
A reviewed diff in code
- 02
Plan
What would change, computed
- 03
Policy
Checked against guardrails
- 04
Review
A person approves the plan
- 05
Apply
The only path to real
- 06
Roll out
Progressive, reversible
- 07
Observe
SLOs judge the result
The error budget, worked
Choose a month and drag through it. The arithmetic is real; the policy on the right is the kind of rule a team agrees on before the incident, not during it.
- SLO
- 99.9% / 30 d
- Budget
- 43.2 min
- Remaining
- 23.0 min
- Burn rate
- 0.7x
Policy decides
Ship
Budget in hand. It exists to be spent on change, so keep shipping.
Worked model · real arithmetic, invented months · thresholds from the standard multi-window burn-rate pattern
04Agentic systems
Agents are workers with a job description.
A role, a policy, tools served over the Model Context Protocol behind one gateway, a person on every consequential action and an audit record of all of it. Step through a run.
01 · Request · Operator
“Summarise this week’s new exposure paths and open a change for the worst one.”
Representative run · real runtime shape · illustrative request, no production data
Tool domains
Each domain is its own MCP server with its own scopes. The gateway authenticates, scopes and rate-limits every call.
estate
Cloud inventory and reachability
knowledge
Typed knowledge search
memory
Recall and store, with provenance
approval
Human-in-the-loop gates
workflow
Status of long-running work
documents
Structured extraction
browser
Verification in a real browser
change
Diffs into the delivery pipeline
Operating principles
- 01
Read-only by default
Every role starts with no write access. Capability is granted per tool, per scope.
- 02
Tools, not text
Agents act through typed tools behind one gateway, never by emitting commands for someone to paste.
- 03
A person on every consequential action
Anything that changes money, access or production pauses for an approval.
- 04
Everything is recorded
Inputs, tool calls, sources, approver and result. A run can be replayed and audited.
- 05
Evaluated before promoted
A new prompt or model version runs against a fixed evaluation set before it touches real work.
05Knowledge & memory
Knowledge as a living system.
Typed objects joined by typed relationships, so a decision links to its evidence and a runbook to the system it operates. People and agents walk the same graph. Ask it something.
decision ← supports ← evidence
decision → cites → source
decision ← informs ← conceptThe decision arrives with its evidence, its sources and the idea behind it. Nobody has to reconstruct the reasoning from chat history.
Pattern view · generic object types · the working schema stays private
06Autonomous delivery
A factory that builds repositories, including this one.
An architecture becomes a finished repository through dependency-ordered build contracts. Each contract passes a verification gate and leaves evidence. The graph below is this site's own, read from its manifest at build time.
The gate ladder
Nothing is called done on a feeling. A contract is complete when its gate passes and the evidence is written down.
G0
Repository truth
Baseline, branch state, existing failures recorded
G1
Architecture & contracts
Invariants, APIs, schemas and trust boundaries agree
G2
Static quality
Types, lint, schemas, generated code consistent
G3
Unit & domain
Invariants and state transitions proven
G4
Data & integration
Migrations, adapters, isolation, failure paths
G5
Security
Authorisation, secrets, input boundaries, audit
G6
Vertical slice
One real journey through every layer
G7
Full assembly
Every capability connected; nothing is a shell
G8
Deployment & runtime
Preview deploy, smoke tests, health
G9
End-to-end & resilience
Critical journeys, failure states, accessibility
G10
Production completion
Only external activation remains
Evidence for every gate lives beside the code it verifies.
07Geometry & CAD
Geometry that proves itself.
Seating layouts read out of drawings, solved under aisle, pitch and accessibility constraints, and emitted as sheets whose dimensions stay attached to the geometry. Correct by test, not by eye.
- 01
Read
Layouts parsed from CAD
- 02
Extract
Runs, aisles, obstacles
- 03
Solve
Spacing under constraints
- 04
Emit
Sheets with live dimensions
- 05
Prove
Golden files, property tests
08Toolbelt
What the work is made with.
Tools change. The disciplines underneath them (legibility, least privilege, verification, reversibility) are the part that carries over.
Cloud
- Google Cloud
- Shared VPC
- Connectivity hubs
- Hybrid interconnect
- Private service access
- Kubernetes
- Serverless containers
- Pub/Sub
- Cloud SQL
- BigQuery
Infrastructure as code
- Terraform
- Module design
- Policy checks on plans
- Drift detection
Security
- Posture management
- Exposure-path analysis
- Policy as code
- Identity & least privilege
- Evidence automation
Reliability
- SLOs
- Error budgets
- Burn-rate alerting
- Runbooks
- Observability
Applications
- TypeScript
- Next.js
- React
- Python
- FastAPI
- PostgreSQL
- Row-level security
Applied AI
- Claude
- Structured outputs
- Model Context Protocol
- Agent orchestration
- Evaluation harnesses
- Retrieval
Geometry & CAD
- Computational geometry
- Constraint solving
- DXF authoring
- Associative dimensions
Verification
- Property-based tests
- Golden files
- Playwright
- Accessibility audits
- Factory gates
Long form
Read the exhibits.
Hub-and-spoke connectivity for a multi-hundred-project cloud estate
A six-hub Network Connectivity Center topology, Shared VPC, hybrid interconnect, and private service access, designed so that a new workload joins the network by declaring intent in Terraform rather than by opening a ticket.
Read →A living model of a cloud estate
Turning a security posture program from a queue of findings into a queryable model of the whole estate, so that exposure paths, architectural patterns, and evidence are questions you can ask rather than archaeology you have to do.
Read →Governed landing pads for workloads
Kubernetes and serverless containers as the two places a workload is allowed to land, each wrapped in Terraform modules that make the secure configuration the default, with observability and runbooks attached before the first deploy.
Read →Geometry automation for stadium seating layouts
A pipeline that reads seating layouts out of CAD drawings, solves seat spacing under aisle and accessibility constraints, and emits fabrication-ready drawings with associative dimensions, proven correct by golden-file and property tests rather than by eye.
Read →Agent infrastructure and the repository factory
Policy-driven agents with tools, memory, and verification gates; a typed knowledge substrate they can navigate; and a prompt-driven factory that turns an architecture into a finished repository through dependency-ordered build contracts. This site was built by it.
Read →
What is not on this page
Prompts, schemas, rule contents, address plans, identifiers, vendor findings, and anything that belongs to an employer or a client. The shape is the portfolio. The recipe is the business.