What you'll learn: how to answer six more interview questions (a committed API key, what to log, a model provider outage, a gap between test results and production, delivering bad news and deciding with incomplete information) with a first move, a number, a bound and a reflection.
At a glance
Figure 1. The first move for each of the six questions
How to read this: every branch ends in a first action, because interviewers listen for what you do in the first minute.
- Optional extension: six shorter questions in the same shape as the reference pages.
- Security and reliability sketches cite primary sources and use illustrative numbers with the arithmetic shown.
- The two behavioral sketches are labelled composites, not anyone's real experience. Bring your own stories.
- The capstone has no retries, no fallback and an in-sample evaluation, and the sketches say so where it matters.
- Nothing here describes how any company interviews.
Scenario
Composite scenario, not a real company. A candidate with a background in back-office integrations is preparing for the last round of a forward deployed role. The practice customer is Lumen Industrial Supply, the fictional distributor. A friend plays an engineering manager who will ask three technical questions and three behavioral ones, and the candidate wants one structure that works for both kinds. All numbers are illustrative.
What you will be able to do
- Handle a leaked credential in the right order and say why rewriting history is not the first step.
- Decide what a service should log, what it should not, and how you would debug without content.
- Use Little's law to show why fail-fast timeouts limit the damage of a provider outage.
- Tell a behavioral story with a measure, a decision and a reflection, without inventing details.
Prerequisites
- Identity and tenant isolation, Boundary reliability and Latency, cost and failures.
- The reference pages Security and reliability questions and Behavioral questions; the six here are different.
- Security and threat modelling for the wider threat picture.
Core ideas
In the interview: "What would you do first?" For security and reliability, the first action must stop the damage or limit it; analysis follows. For behavioral questions, the first thing you say is the situation's stakes, not the background.
Q1. A teammate committed a model provider's API key to the shared repository. What do you do in the first hour?
What it assesses. Whether you act in the right order: stop the key from working, then find the scope, then clean up. Rewriting history first is the usual wrong answer.
Answer framework.
- Treat the key as exposed and revoke or rotate it first.
- Check the provider's usage since the commit for anything unexpected.
- Put the new key where the service reads it at runtime, not in the repository.
- Remove it from history if you need to, and tell the people who cloned the repository.
- Add a check that blocks the next one, and write a short note.
Strong answer sketch.
First I rotate the key, because once it is revoked it cannot be used, and that may be sufficient on its own. GitHub's guidance says to revoke or rotate a secret as the first step, and warns that the commit can still be reachable from clones, forks and pull requests, so cleaning history does not make the old key safe. I would then read the provider's usage for the time since the commit, and treat any unfamiliar usage as an incident with a cost. The new key goes in the deployment's secret store. Last I would add secret scanning to the pipeline so the same mistake fails a build.
One common mistake. Rewriting the history, force-pushing and declaring it fixed while the original key still works.
One follow-up. The key was shared by three services. How do you rotate it without an outage?
Q2. An engineer wants to log every prompt and answer to debug a customer's bad answers. What do you say?
What it assesses. Whether you balance the need to debug against the duty not to copy customer text into places with weaker access control.
Answer framework.
- Agree the debugging need: what question do the logs have to answer?
- Separate metadata from content.
- Log metadata by default; capture content only on a narrow, time-limited path.
- Restrict who reads content logs and how long they live.
- Make sure error messages do not leak details to callers.
Strong answer sketch.
| Log by default | Capture only on a narrow path | Do not log |
|---|---|---|
| Trace id, caller role, counts, timings | Request text and retrieved passages for flagged requests | Tokens, passwords and keys |
| Token counts, cost, outcome | Model output for a reviewed sample | Whole request headers |
| Ids of the documents used | Stage-by-stage timings for a flagged request | Personal data that is not needed |
Most debugging questions are "which documents did it use and what did each stage do?" and ids and timings answer those. I would log metadata by default, add a trace id, and keep request text out. If we need content, I would capture it for a flagged sample with redaction, short retention and a smaller group of readers. The OWASP guidance on sensitive information disclosure (LLM02:2025, still LLM02 in the 2026 edition) asks for least privilege on sensitive data and no leaking through error messages. It does not address logging directly, so the log rule is a design choice built on those principles. The capstone's logs follow the metadata rule and drop fields named for the request text and the bearer token.
One common mistake. Turning on full prompt logging "temporarily" in production, then leaving it on.
One follow-up. A customer reports a wrong answer from last Tuesday and you only have metadata. What can you still do?
Q3. The model provider is down for thirty minutes during business hours. What does the user see, and what do you do?
What it assesses. Whether you design the failure path: fail fast, degrade usefully, tell the truth, and avoid making a struggling dependency worse.
Answer framework.
- Detect: set a short timeout and watch the error rate.
- Fail fast so requests do not pile up.
- Degrade: show the part that does not need the model, such as search results.
- Say what is happening and signal it to callers.
- Recover gently: bounded retries, not a flood.
Strong answer sketch.
By Little's law, requests in flight equal arrival rate times time spent waiting. At 5 requests a second and a 30 second timeout, 150 requests sit open; with a 3 second timeout it is 15. So I would shorten the timeout and open a breaker after repeated failures. The user would see the search results with a note that generated answers are paused. For callers, HTTP defines 503 for a server temporarily unable to handle a request, with an optional Retry-After header. When the provider returns, I would retry with limits, not all at once. The capstone returns a generic 500 and has no fallback; it is a reference service, not a production design.