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.
The model’s answer returns through the platform to the tool.
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.
An alternative must support the task and be allowed to receive the data. A failure does not make every fallback acceptable.
Check access first.Authentication establishes who is calling. Authorization decides what that caller may do. Knowing someone’s identity does not grant every permission.
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.
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.
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.
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.
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.
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.
Kubernetes places Pods on nodes. More replicas help only when enough resources and downstream capacity are available.
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.
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.
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.
Track request duration and error rate across many requests.
Illustrative request: 1,000 ms total. The model call dominates this example.
request_id=42 · provider_timeout
A shared request ID connects the event to its trace.
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.
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.
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.
Summarizes the test set.
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.
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.
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.
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.
Before consequential changes: inspect the exact change, run relevant tests and get approval when required. Changing the code can invalidate earlier evidence.
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.
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.
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.
| AI’s decision | A bug exists | No bug exists |
|---|---|---|
| Flags an issue | Useful findingTrue positive | False alarmFalse positive |
| Stays silent | Missed bugFalse negative | Correct silenceTrue negative |
Precision describes the findings.Of the issues flagged, how many are real? Low precision means engineers spend time dismissing false alarms.
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.
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.
This boundary covers changes in the same database transaction. Email, payments or other external effects need their own duplicate protection.
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.
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.
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.
A successful build, a running process and a successful user workflow are three different pieces of evidence.
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.
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.
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:
- 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.
- 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.
- Keep it useful under load and failure.
Combine admission limits, sufficient ready capacity and safe retries. Explain what users experience when capacity runs out.
- 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.