« Phase 00 · Warmup · Track Overview

Hitchhiker's Guide — The Platform Mental Model

The compressed pass. Read this on the train to the interview; read the WARMUP to actually understand it.

The 30-second mental model

An AI platform is five layers deep and three layers wide. Deep: Users & Channels → Control Plane → (Agent Kernel ‖ Knowledge Foundation) → Action Gateway → the bank. Wide: the model layer, the identity layer, and the infrastructure backbone cut across all five.

One sentence explains the whole architecture: the model proposes, the platform disposes. Everything below the kernel exists so a probabilistic component's suggestion becomes a bank action only after identity, policy, contract, quota and evidence have each said yes.

And one arithmetic fact governs what you can promise: serial availabilities multiply. Five layers at three nines is 99.5%, not 99.9%.

The numbers to tattoo on your arm

Five one-liners that carry a design review

1. "Which layer denies this, and which two would have caught it anyway?"
2. "Is that dependency serial or degradable? Because if it's degradable we get an order of magnitude, and if we're pretending it's degradable we're lying about our SLO."
3. "Where's the headroom in the latency budget? Because that's the fallback."
4. "What's the cost per successful action?"
5. "What artifact does this control emit? If nothing, audit will say the control doesn't exist."

The framework one-liners

• SLI / SLO / SLA — a measurement, a target, a contract. Design the first two; legal signs the third, and always looser than your SLO.
• Error budget — \( 1 - \text{SLO} \). Meant to be spent. A team at 100% remaining is over-invested in reliability.
• Multi-window multi-burn-rate — page when a long window and its short window (≈1/12 of it) both exceed the threshold. Long alone is slow; short alone is jumpy.
• Fail static — when the control plane is unreachable, the data plane keeps enforcing the last known-good config. Not fail-open (a hole), not fail-shut (an outage).
• Two-in-a-box — undivided accountability for one surface, shared pager, an error-budget policy signed before the first breach, and an agreed disagreement protocol.
• Degradation ladder — the ordered list of what you shed under pressure. Written in daylight, executed at 3 a.m. Rerank → cheaper model → cache-only → read-only → queue.

Vocabulary that shows up in every meeting

Blast radius · who is affected when this fails. Bulkhead · isolated resource pools so one tenant cannot drown another. Golden path · the supported, easiest way to do a common thing. Noisy neighbour · one tenant degrading another. Toil · manual repetitive work that scales with load. ORR · the gate before production. ADR · one decision, recorded, immutable. Showback vs chargeback · reporting spend vs actually billing it — the behavioural difference is enormous. Fail static · see above; nobody remembers this third option and it wins arguments.

War stories (the shapes, not the companies)

The SLO nobody composed. A platform team published 99.9% because each of its services was "three nines." Six services in series → 99.4%. They breached in month one, and the fix took a quarter because the architecture had to change (degradable retrieval, provider fallback), not the code. Lesson: compose before you publish. The number you can offer is a property of the topology, not of ambition.

The fallback that made it worse. A gateway added a second provider with a 4-second timeout, inside a 3-second p95 budget. Every provider blip turned a partial degradation into a total SLO breach, because every failover request breached on its own. Lesson: the fallback's timeout must fit the headroom, or shed something first.

The agent with forty tools. A team believed more tools meant more capability. Task success fell: more choices raised selection error (lower p) and longer plans (higher n), and \( p^n \) did the rest. Replacing eleven primitives with two composite tools took success from 41% to 88%. Lesson: capability is not the union of tools.

The cache that leaked. A semantic cache keyed on prompt embedding, no tenant in the key. Hit rate 34%, everyone delighted — until a Retail user got a Wholesale answer for a near-duplicate question. Lesson: every cache key in a multi-tenant platform starts with the tenant.

The examiner's question. "Show me who authorized this action." The team had logs — actor, action, result — but not the policy version, not the model version, not the delegation chain, and no link between the approval and the execution. Six weeks of remediation. Lesson: evidence is a design input.

Beginner mistakes

1. Quoting an SLO without multiplying the chain.
2. Counting a genuinely serial dependency as degradable because it "usually works."
3. Assuming two replicas in one region are independent.
4. Alerting on a single window.
5. Putting answer quality in the availability SLI — now nobody can act on it during an incident.
6. Designing a latency budget with zero headroom.
7. Retrying a money-moving call without an idempotency key.
8. Optimizing cost per token instead of cost per successful action.
9. Treating the control plane as a synchronous dependency of the data plane.
10. Calling it two-in-a-box when accountability is actually partitioned.

What "good" sounds like

"Composed, the read path is 99.10% today. Making retrieval degradable gets us to 99.50%; a second model provider with tested, budget-aware fallback gets us to 99.66% after assuming 20% common-mode correlation. The action path is capped by core banking at 99.7%, so it lands at 99.36%. I'd publish 99.5% read and 99.3% action with a degradation ladder rather than promise 99.9% and breach it. Budget's 3 h 36 m, allocated 40/30/20/10 by last quarter's incident minutes, and the policy freezes feature work at zero remaining — which we signed in January so nobody has to argue about it in March."