Platform Notes

A visual guide for your interview

Understand the pieces.
See how they connect.

A platform team builds shared tools that help other engineers do their work. Here, the central idea is an AI platform that makes models easier to access, control and operate.

Start with the picture below. Each topic gives you a problem to solve, an example interview question, a diagram of the concept, and a way to explain your answer.

The big picture

An engineer wants help with a task. Their tool calls a shared platform instead of building its own model connections, access rules and monitoring. That shared platform is the product you would help build.

ONE REQUEST THROUGH AN AI PLATFORM
An engineer’s toolA coding assistant or internal app
sends a request
Shared AI platformChecks access, chooses a model, records what happened
calls an allowed provider
AI modelGenerates an answer

The model’s answer returns through the platform to the tool.

Supporting the whole path
Compute keeps it runningObservability explains its behaviorReleases improve it safely
The connected boxes show the request path. The supporting capabilities keep that path useful and reliable; they are not extra stops each request must visit.

The Software Engineer (Platform Team) posting emphasizes AI gateways, model onboarding, compute, observability, developer tools and reliable delivery. The diagrams are general study examples, not SpaceX’s internal architecture or a prediction of interview questions.

01 · Gateways & proxies

One shared entry point for AI requests.

The problem to solve

Several teams connect their tools directly to AI providers. Each team repeats the same connection and access-control work, so rules drift and it becomes hard to see who is using which model.

Example interview question

How would you give several teams a consistent, controlled way to use different AI models?

A proxy forwards requests to another service. An AI gateway uses that position to apply shared rules: who can call which model, with what limits and visibility.

THE CONCEPT, VISUALLY
Internal tool“Help me understand this code.”
one shared address
GatewayIdentify caller → check permissions and limits → choose route
approved route
Choose one eligible model
Provider APrimary route
Provider BOptional alternative

An alternative must support the task and be allowed to receive the data. A failure does not make every fallback acceptable.

Follow a request from an internal tool through the gateway to one approved provider.
  1. Check access first.Authentication establishes who is calling. Authorization decides what that caller may do. Knowing someone’s identity does not grant every permission.

  2. Keep failure from spreading.A timeout bounds how long to wait. A bounded retry may recover a temporary failure. Backoff adds delay between attempts; jitter varies that delay so clients do not all retry together.

  3. Stop hammering a failing service.A circuit breaker temporarily blocks calls after repeated failures, then probes for recovery. It reduces wasted calls; it does not repair the provider.

The tradeoff to understand

Shared rules simplify every client, but the gateway becomes an important dependency. Its availability and capacity matter to every tool behind it.

Read more: Microsoft: gateway routing AWS: timeouts and retries Microsoft: circuit breakers

02 · Rate limits & queues

Control arrivals, waiting and active work separately.

The problem to solve

Requests arrive faster than the service can finish them. Waiting work piles up, people wait longer, and the service can run out of memory or connections. Immediate retries can add even more work.

Example interview question

How would you keep a busy service responsive when more requests arrive than it can handle?

A busy service needs limits before it runs out of resources. Rate, queue length and concurrency describe different parts of that problem.

THE CONCEPT, VISUALLY
Rate limitHow quickly new work enters
admitted requests
Bounded queueHow much work may wait
a slot opens
Concurrency limitHow much work may run at once

Token bucket: time refills a limited supply of permission tokens. Each admitted request spends one. A full bucket permits a short burst.

Example arrangement. With no token, reject or delay according to policy; a token bucket does not create a queue by itself. A full queue also needs an explicit rejection policy.

Follow the arrows: admission controls arrivals, a bounded queue holds waiting work, and a concurrency limit caps active work.
  1. Rate is work per unit of time.For example, 10 requests per second. A token bucket can allow brief bursts while enforcing a longer-term average. These tokens are permissions, not the text tokens a language model reads.

  2. Concurrency is work happening at once.Slow requests stay active longer. Even a modest arrival rate can exhaust memory or connections if each request takes a long time.

  3. A queue buys time, not capacity.It absorbs short bursts. If work keeps arriving faster than it finishes, the queue fills and waiting becomes unacceptable. Backpressure tells upstream callers to slow down or try later.

The tradeoff to understand

A larger queue rejects fewer short bursts but can make people wait longer. Bound both queue length and waiting time; adding a queue does not make the service faster.

Read more: AWS: token-bucket throttling Google SRE: handling overload

03 · Containers & capacity

A packaged app still needs a place to run.

The problem to solve

An app works on your laptop, but other machines may have different dependencies. Once more engineers use it, one running copy may also be too small. Starting extra copies helps only if they have resources and are ready to serve requests.

Example interview question

How would you run this app consistently on different machines and provide enough ready capacity as usage grows?

A container image packages an app and its dependencies. A container is a running, isolated process from that image. Kubernetes coordinates where groups of containers run and how many copies exist.

THE CONCEPT, VISUALLY
Container imageA packaged app and its dependencies
run a copy
Node · a machine with finite CPU and memory
Pod · Kubernetes’ scheduling unit
ContainerThe running application process
StartingProcess exists
readiness check passes
ReadyEligible for service traffic

Kubernetes places Pods on nodes. More replicas help only when enough resources and downstream capacity are available.

The nested boxes show containment: a container runs in a Pod on a node. The final two boxes distinguish starting from ready.
  1. Package, then place.Docker helps build and run containers. Kubernetes schedules Pods onto nodes with suitable resources. A Pod can contain one or more closely related containers.

  2. Requested capacity is not usable capacity yet.A new copy may wait for resources, download its image and initialize. A readiness check determines whether it should receive service traffic. A liveness check asks whether a running container needs restarting.

  3. Scale the actual bottleneck.More replicas can help a busy application. They cannot raise an external model provider’s quota or fix a slow shared database by themselves.

The tradeoff to understand

Extra ready capacity costs money but absorbs spikes. Starting more copies only after overload begins can leave users waiting during startup.

Read more: Docker: containers Kubernetes: Pods Kubernetes: health probes

04 · Metrics, traces & logs

Three views of the same system.

The problem to solve

Engineers say the coding assistant feels slow, but you do not know where the time goes. The delay could be in your service, a queue or the model provider. Changing the wrong part wastes time and leaves the problem in place.

Example interview question

How would you find what is making the assistant slow and show that your fix helped?

Observability means using a system’s outputs to understand what is happening inside it. Metrics, traces and logs answer complementary questions.

THE CONCEPT, VISUALLY
One symptom: “The coding assistant feels slow.”
MetricsIs the problem widespread?

Track request duration and error rate across many requests.

TraceWhere did one request spend time?
Access check: 50 msQueue: 150 msModel call: 800 ms

Illustrative request: 1,000 ms total. The model call dominates this example.

LogsWhat happened at that point?

request_id=42 · provider_timeout
A shared request ID connects the event to its trace.

Start with the overall symptom, locate the slow part of a request, then inspect the related events. The timing is an illustrative example.
  1. Metrics reveal patterns.Use request counts, error rates and latency distributions. Latency is elapsed time; p95 is the duration that about 95% of measured requests are at or below. An average can hide a slow minority.

  2. Traces connect the steps.A trace follows one request across components. Each timed operation is a span. In the example, the model call is worth investigating before optimizing the short access check.

  3. Logs add event details.Record structured fields and a correlation ID. Avoid logging secrets or sensitive prompts by default, and control who can read the logs.

The tradeoff to understand

More detail helps investigation but adds storage, cost and privacy exposure. Sampling some diagnostic traces can be reasonable; records required for audit may need separate durability guarantees.

Read more: OpenTelemetry: observability signals Google SRE: monitoring

05 · Model evaluation

Better on your tasks matters more than newer.

The problem to solve

A new model gives an impressive demo, and the team wants to replace the current one. You do not yet know whether it handles everyday engineering tasks better, fails on important cases, or adds too much delay or cost.

Example interview question

How would you decide whether to adopt a new model for the team’s actual work?

Model onboarding means deciding whether a model belongs in the platform, connecting it and operating it responsibly. An evaluation gives that decision evidence from representative tasks.

THE CONCEPT, VISUALLY
Candidate modelNew model or version
same tasks for each candidate
Representative evaluationCorrectness · latency · cost · policy
requirements met
Limited rolloutObserve real work before expanding
Overall score

Summarizes the test set.

Critical requirement

Can still block adoption, even if the average improves.

An evaluation is a set of relevant tasks plus a clear way to judge the outputs. A public leaderboard may measure different tasks from yours.

Compare candidates on the same tasks and requirements, then check behavior during a limited rollout.
  1. Define success before comparing.Use tasks like explaining code, proposing a change or calling a tool. Decide what a correct, useful answer looks like, including important failure cases.

  2. Look past the overall average.Inspect results by task and risk. A strong average can hide failures on an essential category. Also compare latency, cost and data-handling requirements.

  3. Keep checking after adoption.Real usage differs from a test set. Record model and prompt versions so regressions are traceable, and keep a route back to an acceptable version.

The tradeoff to understand

A more capable model may be slower or more expensive. Different tasks can justify different models, as long as the routing and permissions stay understandable.

Read more: Google Cloud: evaluation concepts Google SRE: canary releases

06 · Agents & permissions

A model’s suggestion is not permission to act.

The problem to solve

A coding assistant can now edit files and run commands. It might misunderstand the task or follow misleading instructions in a document it reads. Without enforced limits, one bad suggestion could change files or systems outside the intended task.

Example interview question

How would you let an AI agent do useful work while preventing actions outside its allowed scope?

An agent combines a model with tools so it can take actions. The model proposes what to do; trusted software must enforce which actions are allowed.

THE CONCEPT, VISUALLY
Outside contentRepository files, web pages and documents can contain misleading instructions.
Model proposes“Run this command” or “change this file”
request an action
Trusted policyCheck tool, arguments, identity and permission
only if allowed
Limited executionRun in a restricted environment

Before consequential changes: inspect the exact change, run relevant tests and get approval when required. Changing the code can invalidate earlier evidence.

Outside content reaches the model, but tool access crosses an independent permission check before execution.
  1. Treat retrieved content as untrusted input.A document can contain instructions designed to redirect the agent. This is prompt injection. Text claiming to be authoritative must not grant new permissions.

  2. Give tools only the access they need.Least privilege means narrow file, network and credential access. A sandbox restricts where execution can reach; it does not prove that an action is correct.

  3. Match evidence to the actual change.Test and review the exact code that will be applied. Require human approval where the action’s consequences or policy call for it. Recheck relevant evidence when the change is revised.

The tradeoff to understand

More autonomy can save time but increases the consequences of a mistake. Separate low-risk reading from actions that publish, delete, spend or change production.

Read more: OWASP: prompt injection GitHub: responsible use of agents

07 · AI code review

A reviewer can be wrong in two directions.

The problem to solve

An AI reviewer leaves lots of comments, but engineers spend time dismissing false alarms while some real bugs still reach production. Counting comments does not tell you whether the reviewer is helping.

Example interview question

How would you decide whether an AI code reviewer catches real bugs without wasting engineers’ time?

AI review can flag a problem that does not exist, or miss one that does. Useful review depends on the quality of findings and the important bugs that escape detection.

THE CONCEPT, VISUALLY
Compare the AI’s claim with the actual code
AI’s decisionA bug existsNo bug exists
Flags an issueUseful findingTrue positiveFalse alarmFalse positive
Stays silentMissed bugFalse negativeCorrect silenceTrue negative
A finding is a lead to investigate.Read the changed code → reproduce or test the claim → decide whether to fix it.
Read each row as the AI’s decision and each column as the truth. The off-diagonal cells are the two kinds of error.
  1. Precision describes the findings.Of the issues flagged, how many are real? Low precision means engineers spend time dismissing false alarms.

  2. Recall describes the bugs.Of the real bugs, how many were found? You cannot measure missed bugs by looking only at flagged code; inspect unflagged code or use known test cases too.

  3. Validate the claim.Read the surrounding code and requirements. Reproduce the problem or add a relevant test. A confident explanation is not a substitute for evidence.

The tradeoff to understand

Making a reviewer more eager to flag issues may find more bugs and create more false alarms. Judge severity and reviewer time, not just the number of comments.

Read more: GitHub: responsible use of code review Google: precision and recall

08 · Retries & idempotency

A missing reply does not mean the work failed.

The problem to solve

A tool asks the server to create a work item. The server saves it, but the reply is lost and the tool times out. Sending the request again could create a second work item even though the first attempt succeeded.

Example interview question

How can the caller retry after a timeout without creating the same work item twice?

A network timeout leaves the caller uncertain: the server may have finished the work. Idempotency means repeating the same operation has the same intended effect as doing it once.

THE CONCEPT, VISUALLY
Client sends jobStable operation ID: 42
first attempt
One database transaction · all commit or none do
Apply database changeCreate the record or update its state
Save completion for ID 42Store the result alongside the change
Reply lost on the networkThe database may already have committed.
Client retriesSame operation ID: 42
lookup completed operation
Return saved resultNo second database change

This boundary covers changes in the same database transaction. Email, payments or other external effects need their own duplicate protection.

The first attempt commits its database change and saved result together. A retry with the same operation ID reuses that result.
  1. Reuse the same operation ID on a retry.The server must recognize it within a defined retention period. Scope IDs to the caller and operation; reject reuse with a conflicting payload. A new ID can look like new work.

  2. Make duplicate protection atomic.A transaction and a uniqueness rule prevent concurrent retries from both applying the change. Saving the marker after the effect leaves a crash window between them.

  3. Respect the boundary.A database transaction does not include an unrelated email service. An outbox saves a message alongside the database change for later delivery; the receiver still needs to handle duplicate deliveries.

The tradeoff to understand

Retries improve recovery but add load and require duplicate handling. Use bounded attempts and backoff, and retry only operations whose failure and duplicate behavior are understood.

Read more: AWS: idempotent APIs AWS: transactional outbox

09 · Releases & verification

Working locally is the beginning of release evidence.

The problem to solve

A change passes local tests, but production has real traffic, different configuration and other services to depend on. Releasing it to everyone at once could spread a failure before you notice. You need evidence that it works and a way to recover.

Example interview question

How would you release a platform change, verify that it works for users, and recover if it causes problems?

CI checks changes through automated builds and tests. Continuous delivery keeps validated changes ready for release. A canary exposes a small share of real traffic before a wider rollout.

THE CONCEPT, VISUALLY
Build + testPackage the change and check behavior
deploy a candidate
ReadinessCan this instance accept traffic?
expose a small share
Canary releaseObserve real requests and compare versions
Behavior meets the target→ Gradually expand the rollout.
Errors or delays increase→ Pause; route back to a known working version when safe.

A successful build, a running process and a successful user workflow are three different pieces of evidence.

Build evidence comes first, readiness permits traffic, and observed behavior determines whether to expand or recover.
  1. Verify the actual user path.DNS must resolve the name, TLS must secure the connection, the app must respond, and the intended workflow must succeed. Any one check alone is incomplete.

  2. Compare versions using meaningful signals.Track errors, latency and task success for the candidate versus the current version. Predefine when to pause or roll back instead of deciding under pressure.

  3. Prepare recovery before changing traffic.Keep known working artifacts and compatible configuration. Database migrations can make rollback harder, so plan data compatibility too. Infrastructure as code makes environment changes reviewable and repeatable.

The tradeoff to understand

Gradual releases add operational work but limit how many users a defect reaches. Small, reversible changes are easier to diagnose and recover than a large batch.

Read more: Google SRE: canary releases Kubernetes: deployments and rollback

Put it together

Reason from the user’s problem.

Suppose an interviewer asks how you would build a shared coding assistant. These concepts fit into one line of reasoning:

  1. Understand the work.

    Who will use it? Which task should get easier? What data is involved, and how will you know the tool is useful? This shapes model evaluation and the product’s first version.

  2. Control the path from request to action.

    Use a gateway for shared model access and permission checks for tools that can act. They protect different boundaries.

  3. Keep it useful under load and failure.

    Combine admission limits, sufficient ready capacity and safe retries. Explain what users experience when capacity runs out.

  4. Use evidence to improve it.

    Observe real behavior, validate AI review findings and release gradually. Ask engineers what helps, and measure useful task completion as well as reliability.

THE THREAD THROUGH ALL NINE

“I’d start with the engineer’s task and constraints, build the smallest useful path, control access and load, measure whether it works, then improve it through small, verifiable changes.”

You do not need to recite every mechanism. Being able to explain the problem, draw the path and discuss one tradeoff gives you a useful foundation for a deeper conversation.