Route Before You Build
Updated
IntermediateWhat you'll learn
~15 min- Separate workload-routing decisions into orthogonal axes that never collapse
- Drive routing from a typed intake through a deterministic decision table
- Emit one decision-complete contract that downstream tooling consumes
The platform team’s recurring Tuesday
A product team arrives: “we’re building a thing — set us up.” Every platform team fields this weekly, and most answer it artisanally: a meeting, a whiteboard, a bespoke pile of decisions that lives in nobody’s head a quarter later. By the fifth team, the answers have drifted apart, and the estate is five snowflakes deep.
The pattern this lesson teaches — drawn from a real platform team’s routing framework, the strongest single artifact in this training’s source material — replaces the artisanal Tuesday with a deterministic routing system. Its design has three load-bearing ideas.
Idea 1: orthogonal axes, never collapsed
Every “set us up” decision is actually four independent questions, and the framework’s core rule is refusing to let them contaminate each other in this four-axis structure:
AXIS 1 workloadArchetype WHAT is it? application+database (default) | api | integration | data-platform | mixedAXIS 2 topologyLane what assurance/isolation/handoff shape? shared-standard | gov-moderate | enclaved-high | (specialized extensions)AXIS 3 providerTarget WHICH cloud/region family?AXIS 4 referenceArchitecture what runtime shape serves it?The rule matters because collapsed axes are how routing systems rot: “government workloads go on VMs” fuses lane with architecture; “APIs mean the shared cluster” fuses archetype with provider. Each fusion bakes one moment’s coincidence into policy. Kept orthogonal, a data-platform workload in the high-assurance lane on the sovereign cloud is just a coordinate — no rule needed to anticipate the combination.
Idea 2: typed intake, deterministic table
Routing inputs come from a six-question intake a product owner can answer with zero cloud knowledge (what kind of thing is it, who uses it, what data sensitivity, what assurance regime, expected scale, any hard constraints) — producing a small typed vector. That vector hits a decision table — rules keyed primarily on assurance level — and resolves to a named, pre-computed profile. Not a score, not a weighted rubric, not a conversation: a table lookup you can read, diff, and argue about in a PR.
The design virtue is reviewability of the rules themselves: when the table routes something surprisingly, the fix is a visible table edit with a commit message — versus the artisanal world, where the fix is “remember to decide differently next time.”
Idea 3: one decision-complete contract
Whatever profile wins, the output is always the same ten-field contract: archetype, lane, provider, reference architecture, compliance-monitoring mode, network posture, environment model, handoff rule, pipeline family, evidence model. Ten fields, and the receiving team’s every downstream question — which pipeline templates? what network shape? who provisions what? what evidence collects? — is answered by a field, not a meeting.
“Decision-complete” is the standard to hold it to: if any downstream step still needs a judgment call, the contract is missing a field. And because every workload emits the same shape, the contract becomes the interface the whole platform builds against — Lesson 6.1 shows the payoff, where starters, IaC, and handoff packets are generated from it (with a CI check that fails when generated surfaces drift from the source table — the full productization machinery lives there, not here).
Prompt first
Switch your workspace agent to Plan mode on your platform repository and ask it to design version 1 of the routing decision system (if you do not have live exports or files handy, ask it to generate a small Meridian practice sample from the lesson’s scenario first):
Plan our v1 workload-routing system: a six-question typed intake, an assurance-keyed decision table resolving to 4 to 6 profiles, and a ten-field output contract. Route our three sample Meridian requests and flag any vector requiring human review.Check that the plan or draft covers:
- The six-question intake with typed, enumerated allowed values
- A deterministic decision table keyed on assurance first, resolving realistic intake vectors to 4 to 6 named profiles and routing unresolved vectors to an explicit
"talk to the platform team"row - The ten-field contract emitted by every profile (archetype, lane, provider, reference architecture, compliance-monitoring mode, network posture, environment model, handoff rule, pipeline family, and evidence model) naming which downstream consumer reads each field
- Sample contracts for all three Meridian requests: (a) the internal crew-scheduling web app with a database at moderate sensitivity, (b) the read-only public outage API, and (c) the meter-telemetry analytics workspace
If the table routes the analytics workspace to a push-button starter, follow up with: Route data-platform archetypes to guided customization rather than an automated push-button starter.
The three sample routings are the artifact, and request (c) should teach you something the source framework encoded deliberately: data-platform archetypes got routed to guided customization, never a push-button starter, because the framework’s designers knew where deterministic routing’s edge was. A routing system that knows its own limits and says “human, here” at them is mature; one that routes everything is lying somewhere.
The fastest way to validate a decision table: replay history. Feed last year’s real “set us up” requests through the table and diff its answers against what was actually built. Every mismatch is either a table bug (fix the rule) or an estate inconsistency (now you know where the snowflakes are). This is Lesson 1.2’s audit-docs-against-reality habit, pointed at decisions instead of branches.
Six months in, a platform engineer proposes simplifying the table: 'Every gov-moderate request so far has been an application+database on the standard runtime — let's just make gov-moderate imply those and drop the separate questions.' What does the framework's design say?
Key takeaway
Route before you build: four axes kept orthogonal, a typed six-question intake, a deterministic table that resolves to named profiles, and one ten-field decision-complete contract that downstream tooling consumes. Reviewable rules beat remembered wisdom, defaults beat fusions, and a table that knows where to say “human, here” beats one that routes everything. Module 2 builds the thing the contract’s pipeline-family field points at.