InterviewsVector
Arc 11
Design reviewAdvanced110 min estimateOriginal publication

Draw the AI Platform Boundaries

A platform is an internal product with an explicit contract: name the consumers, paved roads, escape hatches, data and control planes, decision rights, reliability model, and accountable owners before centralizing code.

Authorship
InterviewsVector
Published / updated
2026-09-27 / 2026-09-27
Review status
Artifact tests passing · primary sources recorded

Original InterviewsVector teaching. Executable artifacts are deterministic illustrative audits with focused tests and recorded primary sources; they do not claim procurement approval, vendor qualification, security certification, production readiness, measured SLOs, financial forecasts, benchmark results, or universal architecture guidance.

The decision in one pass

Draw an AI platform around repeated obligations whose centralized implementation produces a safer or faster default: authenticated model access, tenant and budget enforcement, provider adapters, evaluation primitives, release evidence, observability, policy distribution, and incident controls. Do not centralize product prompts, domain labels, user experience, task-specific thresholds, or business degradation decisions merely because they invoke a model. For each platform capability, publish the consumer, interface and versioning, data plane, control plane, evidence plane, accountable owner, runtime and on-call owner, change authority, tenant and data boundary, SLO, fallback, and deprecation path. Offer a paved road that is easier than bespoke implementation plus a governed escape hatch. Measure adoption, task completion, cognitive load, lead time, reliability, policy coverage, cost, and consumer satisfaction—not ticket volume or mandatory usage. Split the platform when its consumers, risk, scale, or operating model require different boundaries.

Why this matters

Without a platform, teams duplicate credentials, adapters, evaluation plumbing, telemetry, controls, and incident logic. With an over-broad platform, a central team becomes the approval queue for every prompt and feature while owning failures it cannot understand. Ambiguous boundaries create orphaned alerts, unreviewed policy changes, confused deputies, shared-tenant leakage, and incompatible abstractions. The technical architecture and team topology must tell the same ownership story.

You will be able to

  • Separate product-specific decisions from cross-cutting platform capabilities using explicit consumers and obligations.
  • Map data, control, and evidence planes with versioned interfaces and failure behavior.
  • Assign accountable, runtime, on-call, change, fallback, tenant, and telemetry ownership for every capability.
  • Design paved roads, escape hatches, deprecation, and feedback so standardization remains useful rather than coercive.
  • Evaluate platform health through consumer and production outcomes rather than central-team activity.

Your Vector Loop for this lab

  1. 01

    Model

    Map consumers, journeys, repeated obligations, product decisions, tenancy, data, dependencies, operating risks, current duplication, and organizational capabilities.

  2. 02

    Derive

    Derive capability boundaries, planes, interfaces, authority, ownership, SLOs, isolation, fallback, deprecation, escape, and evidence contracts.

  3. 03

    Build

    Build a deterministic audit that compares invented capability evidence with an immutable platform charter and exposes every boundary mismatch.

  4. 04

    Stress

    Remove owners, swap planes, bypass tenant context, expand privilege, lose telemetry, open fail modes, add undeclared capabilities, and age review evidence.

  5. 05

    Operate

    Monitor consumer outcomes, adoption, lead time, reliability, task quality, policy coverage, incidents, cost allocation, toil, exceptions, interface drift, and deprecations.

  6. 06

    Defend

    Defend why each capability is shared, what the platform refuses to own, how consumers can leave, and why a local structural pass is not security certification.

Start from consumer journeys, not a central team chart

An internal AI platform serves product engineers, applied researchers, evaluators, security and policy teams, reliability engineers, and finance operators. Map what each consumer is trying to accomplish and where repeated work or risk blocks them. A capability belongs on the platform when a shared contract measurably reduces cognitive load, duplicated risk, or lead time while preserving domain ownership. A central team's desire for uniformity is not sufficient evidence.

Usually sharedUsually product-ownedRequires an explicit boundary
authenticated model accesstask semantics and user experiencewho may invoke which capability for which tenant
provider and runtime adaptersprompt and workflow behaviorwhat compatibility the internal interface promises
evaluation and evidence primitiveslabels, slices, thresholds, release decisionwho can change the gate and who signs the release
telemetry schemas and transportproduct outcome interpretationcontent capture, retention, redaction, and access
budget and quota enforcementbusiness priority and degradationwhat happens when a budget is exhausted

Separate planes and name decision rights

PlaneExamplesFailure concern
datarequest validation, model calls, retrieval, tool executionlatency, isolation, overload, semantic fallback
controlmodel catalog, policy, budgets, rollout, credentialsstale or unsafe configuration and blast radius
evidenceevaluation records, traces, lineage, cost, incidentsmissing, misleading, sensitive, or unowned proof
experienceSDK, portal, templates, documentation, supportconsumer bypass, friction, hidden coupling, ticket queues
  1. 01Name the consumer and promiseState who uses the capability, for which journey, under which support and compatibility contract.
  2. 02Define the interface and authoritySpecify schema, identity, version, errors, quotas, idempotency, change approver, rollout, rollback, and deprecation.
  3. 03Bind tenant and data contextCarry authenticated scope through authorization, storage, cache, telemetry, providers, policy, deletion, and billing.
  4. 04Assign operating ownershipName accountable, runtime, on-call, fallback, incident, and consumer owners with escalation and handoff rules.
  5. 05Publish the escape hatchPermit a time-bounded alternative when requirements do not fit, while preserving mandatory security, audit, and policy controls.

Audit ownership and enforcement evidence together

platform_boundary_audit.py
1def audit_platform_boundaries(contract, evidence):
2 contract = validate_record(contract, PlatformBoundaryContract)
3 evidence = validate_record(evidence, PlatformBoundaryEvidence)
4 if evidence.scope != contract.scope or evidence.contract_content_id != contract.content_id:
5 raise ValueError("evidence belongs to another platform-boundary contract")
6 # Compare every declared capability's plane, owner, change authority,
7 # tenant context, privilege review, telemetry, fail mode, and freshness.

Expected output

example=illustrative_only
decision=PASS_BOUNDARY_AUDIT
capabilities=evaluation,identity,incident-response,model-access,observability,prompt-policy
violations=
claim=LOCAL_BOUNDARY_AUDIT_NOT_DEPLOYMENT_OR_SECURITY_CERTIFICATION

Verify: python3 -m unittest discover courses/ai-engineering/reference-impl/ai_platform_boundaries

The invented charter declares six capabilities and binds each to a control or data plane, exact interface, accountable owner, runtime owner, on-call owner, change authority, fallback owner, and fail-closed requirement where applicable. Evidence adds tenant-context, least-privilege, telemetry, freshness, and digest claims. The audit reports missing and undeclared capabilities separately and never treats a complete owner field as proof that the corresponding control exists in production.

Find the broken platform boundary

Review an invented capability map with plane, owner, change authority, tenant context, least privilege, telemetry, fail-mode, and freshness evidence. Predict the first contract violation.

Place a capability on the ownership map

A platform boundary is an ownership contract, not a diagram box. Decide from common semantics, reuse, risk, operating responsibility, and reversibility.

Select a boundary scenario

Illustrative organizational evidence only. A real boundary needs named owners, consumers, SLOs, funding, and an exception path.

Boundary and ownership evidence
SignalDeclared constraintAvailable evidence
reuseshared by ≥ 4 productsseven products duplicate the same controls
semanticscommon across domainsidentity, spend, retry, and trace rules are identical
riskcentral control reduces exposurethree credential incidents came from local implementations
ownershipnamed team and SLOplatform team owns the contract and 24/7 response
Where should this capability live now?

Commit to a decision before revealing the bounded recommendation.

Make the paved road attractive and the escape hatch governed

A platform earns adoption when the default path is documented, observable, supported, fast to start, safe to change, and easier than rebuilding its controls. Mandatory adoption can hide dissatisfaction and encourage shadow systems. Provide reference implementations, local test doubles, clear errors, compatibility windows, migration tooling, cost visibility, and office hours. Let consumers request an exception with a reason, owner, compensating controls, evidence, expiry, and path back—or use the exception as evidence that the platform boundary should change.

MetricUseful interpretationMisleading substitute
time to first safe callconsumer lead time through required controlsSDK download count
successful task adoptioneligible workloads choosing the paved roadmandated account count
consumer cognitive loadconcepts and operations teams must ownnumber of portal features
reliability and qualityproduct-visible outcomes by workloadplatform process uptime alone
exception and bypass ratewhere the boundary fails real needstickets closed by the platform team
deprecation completionconsumers safely leave old interfacesannouncement sent

Evolve the platform and its ownership together

  • Use consumer councils and production evidence to prioritize contract changes; central intuition is not product discovery.
  • Version interfaces, policies, model capabilities, telemetry schemas, and ownership maps; coordinate compatibility rather than relying on synchronized releases.
  • Run production-readiness reviews for new platform capabilities and for high-impact consumers, with explicit gaps and acceptance owners.
  • Keep product developers in incident and on-call feedback loops so domain failures do not become platform mysteries.
  • Split capabilities when risk class, latency path, tenant isolation, geography, scale, or consumer workflow needs a different operating model.
  • Retire unused features and interfaces; platform scope should be earned continuously, not accumulated indefinitely.

Operate at three altitudes

Production lens

  • — Alert by user and consumer impact while routing every platform capability to an explicit on-call and fallback owner; central dashboards without response authority are decoration.
  • — Version and audit tenant propagation, authorization, interfaces, policy, telemetry, rollout, fallback, exceptions, and deprecation across the complete call path.
  • — Load- and failure-test both data and control planes, including stale configuration, identity failure, policy unavailability, telemetry loss, noisy tenants, provider faults, and platform bypass.

Staff lens

  • — Optimize the sociotechnical boundary: put authority, context, incentives, and operational feedback with the teams capable of changing the outcome.
  • — Treat platform scope as a portfolio of internal products with explicit consumers and retirement criteria, not a permanent mandate to absorb adjacent systems.
  • — Make paved-road adoption an outcome of lower cognitive load and stronger defaults while keeping mandatory cross-cutting obligations explicit and auditable.

Interview defense

Design the boundary and ownership model for a shared AI platform used by many product teams.

I would start with consumer journeys and repeated cross-cutting obligations, then separate shared capabilities from product-owned task semantics. For each capability I would publish data, control, evidence, and experience planes; a versioned interface; authenticated tenant and data scope; accountable, runtime, on-call, fallback, and change owners; SLO, telemetry, fail mode, rollout, rollback, and deprecation. The platform would provide an attractive paved road and a time-bounded governed escape hatch. I would measure consumer lead time, cognitive load, eligible adoption, product-visible quality and reliability, cost, incidents, exceptions, and deprecation—not ticket volume. Ownership and scope would change when risk, scale, consumers, or operating feedback demand a new boundary.

Expect the interviewer to press on

  • — Which concerns belong in the platform versus the product?
  • — How do you prevent a central team from becoming an approval bottleneck?
  • — What isolation claim does a namespace actually support?
  • — When would you split one platform capability into a separate service or team?

Misconceptions to remove

“A platform should maximize the number of shared features.”

It should minimize repeated cognitive load and risk for named consumer journeys. Extra scope adds coupling, operating surface, and coordination cost unless it earns adoption through value.

“One platform team should own every AI production outcome.”

The platform lacks domain context and product authority for many outcomes. It owns its contracts and shared controls; product teams retain task quality, user experience, and business decisions.

“Standardization requires forbidding escape hatches.”

A governed exception exposes unmet requirements and preserves delivery. Mandatory security or audit controls can remain while the implementation path differs temporarily.

Check your model

1. What four planes should a platform capability make visible?

The request data plane, configuration and rollout control plane, evaluation and telemetry evidence plane, and consumer experience plane including SDKs, documentation, support, and migration.

2. Why is accountable ownership not enough by itself?

Runtime, on-call, change, incident, fallback, tenant, evidence, and consumer responsibilities may sit with different teams; each needs authority and an explicit handoff contract.

3. What does a high exception rate tell a platform team?

It may reveal a missing consumer segment, an abstraction that hides important differences, excessive friction, or a control the platform cannot yet satisfy; investigate before enforcing adoption.

Prove the mechanism

Extend the artifact with interface compatibility windows, consumer acknowledgements, and exception expiry. Preserve immutable ownership rules, complete capability coverage, deterministic violations, and separate structural claims from runtime proof.

Add a production constraint

Create a platform charter for identity, model access, prompt policy, retrieval, evaluation, observability, incident response, and cost. Include consumer journeys, planes, interfaces, tenant and data boundaries, owners and authority, SLOs, fallbacks, paved roads, escape hatches, metrics, deprecation, and a failure exercise.

Artifact: AI platform boundary and ownership contract

courses/ai-engineering/reference-impl/ai_platform_boundaries/platform_boundary_audit.py

Download reference implementation

Primary references and next links

References

  1. 1. Multi-tenancy

    Kubernetes. Official guidance on tenant models, authorization, quotas, control-plane and data-plane isolation, and the limits of namespace boundaries.

  2. 2. SRE Engagement Model

    Google SRE. Primary guidance on service lifecycle, production readiness, shared goals, operating responsibility, and ownership transitions.

  3. 3. Artificial Intelligence Risk Management Framework (AI RMF 1.0)

    NIST. Primary framework for AI governance, roles, accountability, measurement, risk ownership, and lifecycle management.

Continue through the graph

Glossary: internal platform · paved road · escape hatch · data plane · control plane · evidence plane · tenant boundary · decision right · cognitive load · production readiness review