There is no calibration to hide behind, so the loop is whatever the founder or lead believes predicts performance - most often a practical build, then a conversation about the trade-offs you chose. Breadth is the bar: the same person is expected to ship the feature, its migration, its metrics, and its on-call. Behavioural rounds are less about principles than about tolerance for ambiguity and whether you make decisions when nobody hands you the requirement.
Scored on top of a correct answer
•What you deliberately left out, and whether you can defend cutting scope to ship
•Operational instinct: how the thing you built is monitored, rolled back, and paid for
•Whether you decide without a spec instead of waiting to be told
How candidates lose it
Over-engineering the take-home, which reads as someone who cannot judge stage-appropriate scope
Deferring every product question to a product manager who does not exist yet
Depth in one layer with no idea how the thing runs in production
One week: how to spend it
Front-load breadth, put the two hardest rounds mid-week when you still have time to react to a bad session, and keep the last evening for a timed loop and your stories. Two hours a night done every night beats one eight-hour Saturday, because retrieval improves with spacing and a single long session mostly produces the feeling of having worked.
The plan
1Day 1 - fundamentals sweep
about 3.5 hr
Read the sheets for the core sections of this track at speed. Mark the items you could not answer; they become your revision list all week.
Return a strong ETag on GET, require If-Match on writes, and reject a stale token with 412 Precondition Failed so a lost update becomes a visible error rather than silent data loss. What makes it correct is that the comparison and the write must be one atomic operation - an UPDATE guarded by the version in its WHERE clause - because a SELECT then UPDATE reintroduces the race.
A catch handler that returns normally converts a rejected promise into a fulfilled one, so every then after it runs as though nothing failed. Combined with fetch, which only rejects on network errors and resolves happily on a 500, the chain reports success twice over. Fix by re-throwing from catch, checking response.ok, and modelling UI state as a machine.
Decide what may cross the provider boundary and redact before it does, checking the provider's retention and training-use terms rather than assuming them. Then treat the debugging trace as a second copy of user data, with its own retention, access control and deletion obligations.
Roughly 200 near-full copies, because delta compression works on text and a relinked binary differs throughout, so each version costs almost its own size. Deleting the file changes nothing: history is content-addressed and every past commit still reaches the blob. The design fix is that build outputs belong in a registry that can expire them, because version control is built never to forget.
Soft deletion is a modelling decision rather than a convenience: it silently breaks uniqueness, leaves foreign keys pointing at rows that are logically gone, and adds a predicate every future query has to remember. Model the lifecycle explicitly instead.
A saga has no rollback. Each step already committed in its own database and was visible to everyone, so you can only run new forward transactions that semantically offset it. Compensations are not atomic, some actions cannot be compensated at all, and compensations themselves fail - so a saga needs idempotent handlers and an ordering rule for irreversible steps.
CPU is compressible, so the kubelet throttles it rather than evicting for it. Eviction comes from memory, ephemeral storage or inodes - and which pods die is decided by QoS class, not by who caused the pressure. Check node conditions and eviction thresholds first, then fix the requests and limits so critical workloads are Guaranteed rather than BestEffort.
The dialog was built as a styled div, so nothing marks the rest of the page inert. Focus was never moved in, never constrained, never restored on close, and Escape was never wired. A correct dialog moves focus in, keeps it in, restores it, marks background inert and is labelled - which native dialog with showModal gives you almost for free.
The KV cache stores the attention keys and values of every token a sequence has seen, so decoding need not recompute them. It grows with tokens per sequence and with concurrent sequences, and after the weights it fills GPU memory, so tokens in flight, not requests, set how many users one GPU serves.
Decide from evidence, not intuition: per-index scan counts read against the date the statistics were reset, redundancy judged by leading columns, and the constraints and foreign keys that need an index whether or not anything ever scans them. Then make the drop reversible.
A global limit protects the service from overload but says nothing about how capacity is divided, so one tenant can consume most of it while staying under the ceiling. Fairness needs per-tenant accounting: a token bucket for the steady-state contract, a concurrency limit so expensive requests cannot hog workers, and round-robin queueing so a burst queues behind itself.
The queue records that work was sent but cannot know whether the server received it, so any crash between sending and recording the acknowledgement replays the action. At-least-once delivery is the only thing a mobile client can guarantee, so the fix is to make the operation idempotent with a client-generated key persisted alongside the queued action, not to try harder to deliver exactly once.
The endpoint is an unauthenticated internet-facing entry point that writes to your core systems, so treat every field as attacker-controlled. Verify an HMAC over the raw body in constant time, reject stale timestamps, deduplicate on event id, bound the body size, and hand off to a queue rather than processing inline.
The contract captured the shape the consumer sends, not the rules the provider enforces. Optionality lived in the schema while the real requirement lived in provider validation, and no recorded example ever omitted the field. Contract tests only verify interactions they contain, so add the negative example and verify against real code.
A single threshold on a single window cannot separate a real outage from a brief spike, so it either pages on noise or misses slow burns. Replace it with multi-window multi-burn-rate alerting: a fast rule that pages and a slow rule that files a ticket, each gated by a short window so a spike that already stopped does not keep paging.
Async controls when a script downloads, not what it does to the main thread once it executes, so an async tag can still block interaction handling. Prove it with field data attributed to the interaction: INP breaks into input delay, processing and presentation, and each points elsewhere. Then move the work off the critical path.
Every distinct combination of label values is a separate time series with its own index entry, so an unbounded label multiplies series count by the number of users rather than adding one dimension. Metrics are the wrong tool for per-entity questions: keep labels bounded, move per-user debugging to exemplar-linked traces, and guard against the next unbounded label.
gRPC multiplexes many calls over one long-lived HTTP/2 connection, so a balancer that distributes connections pins each client to one backend for its lifetime. Balance per request with an HTTP/2-aware proxy or client-side subchannels, and bound connection age so scaling out actually moves traffic.
Inventory everywhere the model is coupled to behaviour, then use the eval set as your migration harness, shadow the candidate on live traffic to compare without user exposure, and re-measure cost and latency because both shift. Use the migration to delete instructions that only compensated for the old model.
Two transactions can each run the SELECT before either commits, so neither sees the other and both inserts succeed. The fix is a serialisation point the database owns - a unique index on a natural or client-supplied key - plus a defined answer for whoever loses the race. It also connects idempotency to the point an interviewer is testing.
Revoke once in the authorisation store, then propagate to the index ACLs, every cache holding text or results, any derived summaries and embeddings, and the conversation transcripts still carrying passages. Answers already delivered cannot be recalled, so the guarantee you offer is a bounded window rather than erasure.
An acknowledged write is only guaranteed on the replicas that acknowledged it, so a read served elsewhere can legitimately return the previous version. Locate the staleness - replica, secondary index or cache - then buy read-your-writes for that operation only, and price what it costs during a partition.
Guardrail metrics are outcomes you are not trying to improve but will not let degrade beyond a margin declared before launch. They stop a launch when the data shows harm past that margin, or cannot rule it out, which means guardrails need their own power and their own pre-agreed decision rule.
When a Terraform plan wants to destroy production, stop and identify whether the diff comes from state drift, a provider change, a renamed resource or real configuration intent. Do not approve until the blast radius is understood. It also connects IAC to the point an interviewer is testing.
The system is being held down by effects it now generates itself: accumulated client retries, an empty cache multiplying database load, and a queue of requests whose callers have already given up. Recovery needs shed load and a controlled ramp, not more capacity.
Subtract the answer reservation and the fixed prompt first, give retrieval a token allowance rather than a passage count, and let conversation history have what remains under an explicit eviction policy - because history is the only term that grows every turn while everything else stays flat.
Separate the leverage from the merit: the renewal makes the request urgent, it does not make it valuable. Work out the real problem underneath the requested solution, test whether it generalises to other accounts, and price the full cost including permanent maintenance rather than the build estimate. Then choose deliberately between roadmap, configuration, services and no.
Vectors from two models live in unrelated spaces, so there is no incremental path — you re-embed and reindex the whole corpus. The real cost is running both indexes side by side long enough to compare them on a gold set, keeping query and document models in step, and retuning thresholds calibrated on the old scores.
Every producer must have a declared answer — block, buffer to a bounded local store, or drop — chosen per event class rather than once for the whole fleet, because the default of blocking on a full in-memory buffer turns a broker outage into an outage of every service that publishes to it.
Cache hashed assets for a year and never cache the entry document, retain several previous builds so a stale tab can still fetch its chunks, and treat a failed dynamic import as the signal to prompt a reload rather than as an error to swallow.
Separate the layers that can fail together: routing reachability, name resolution, identity and physical access. Then build an access path that shares none of them, keep controls failing static rather than closed, and rehearse the emergency path often enough that it is known to work.
Permission data is as privileged as the code that reads it, so a bulk write to it needs the same review, staged rollout and reversibility as a deploy. Derive grants from a source of truth rather than stamping them, assert tenant invariants continuously, and know how long a cached decision keeps the mistake alive.
Assess the candidate's expertise in distributed systems within the browser, focusing on Conflict-free Replicated Data Types, memory optimisation, and peer-to-peer state synchronisation. Use this frontend answer to show the decision, trade-off, and evidence rather than a memorised definition. It also connects architecture to the point an interviewer is testing.
Report two rates separately: ungroundedness, meaning claims the provided sources do not support, and factual error, meaning claims wrong about the world. Measure per claim, publish the abstention rate beside them, and name the query set that produced the numbers. Use this hallucination answer to show the decision, trade-off, and evidence rather than a memorised definition.
Treat blocked access as a research design problem rather than a blocker. Make the account team's job easier so they open the door, triangulate the proxies you can reach against behavioural evidence, and state explicitly which decisions your sample cannot support.
A backup job that exits zero is a belief, not a control. Establishing recoverability means agreeing an RPO and RTO, then rehearsing a restore onto clean infrastructure, measuring how long it took and verifying the result — including everything the dump does not contain.
Enforce step, token, wall-clock and monetary budgets in the orchestrator rather than in the prompt, detect repetition and lack of progress as separate conditions, and require an approval bound to specific arguments before any irreversible action. Exhausting a budget should hand back partial work, not vanish.
A plain script in the head stops the parser until it is fetched and run. defer fetches in parallel and runs after parsing, in document order, before DOMContentLoaded. async runs as soon as it arrives, in no guaranteed order. Module scripts are deferred by default and also accept async.
When the same query is fast in psql but slow from the application, first separate database time from connection wait, network transfer and ORM hydration. Then compare the real application plan, bind parameters, session settings, fetch size and result volume.
The file count is the number of writing tasks multiplied by the partition values each task holds, so a wide shuffle plus a high-cardinality partition column produces a file explosion. Repartition to match the write layout rather than coalescing to one task, and compact behind a table format.
Spring Data JPA saveAll batching needs a Hibernate batch size, statements for the same table kept adjacent, and an identifier strategy that does not force a round trip per row. IDENTITY generation silently prevents insert batching, because Hibernate has to execute each insert to learn the key.
Treat any payload the fleet loads as a release, because it changes behaviour in production exactly as a binary does. It needs schema and replay validation, a canary ring with its own health comparison, and a rollback that survives the change breaking whatever would apply the rollback.
The database recovered; your clients did not. Sockets to the old primary hang rather than fail, a cached DNS answer keeps pointing at it, the promoted node refuses writes while it finishes, and then the whole fleet reconnects at once. Attribute the ten minutes to those stages before tuning anything.
Compare it against a genuinely strong prompted baseline on a held-out set drawn from real traffic, using the task metric your product cares about, and run a broad regression set alongside to catch capability lost elsewhere. Falling training loss is evidence that training worked, not that the product improved.
Work out who owns the customer after the deal, because that decides whether this is distribution or the slow loss of your product. Price the engineering the partner's requirements will consume, and set the conditions under which you would walk away before you see the revenue figure.
Read the failing queries first and sort them into causes, then apply the matching lever — rewriting for vague queries, filters for scope errors, smaller retrieval units for buried answers, lexical retrieval for literal terms, a reranker where recall sits below the cut — each with the metric that proves it worked.
Reactive scaling has a latency of its own — metric window, evaluation, provisioning, warm-up, health checks — and a surge that arrives faster than that latency is served entirely by the capacity you already had. The fix is a scheduled floor plus a saturation-based signal, not a more aggressive policy.
Treat thin evidence as a missing decision rather than a weak yes, because a hire made on impressions is a coin flip dressed as a process. Separate what was observed from what was inferred, find which required signals nobody actually tested, and close that gap with a targeted follow-up rather than overruling the room or rubber-stamping it.
Declare it, take the incident commander role explicitly, and mitigate before you diagnose - roll back or shed load first, understand later. Keep one channel as the record, publish updates on a fixed cadence, hand over rather than push through, and let the review produce owned actions instead of narrative.
Name the competing demands, say what you dropped or deferred and who agreed to it, and describe how you told the people whose work was affected. Interviewers listen for a decision made in the open, not for evidence that you absorbed the overload quietly.
Find out what the six weeks is made of before negotiating anything, then choose between cutting scope, splitting the release, launching to a limited cohort and moving the date — and tell everyone who depends on the date the same day you know.
Check whether the increment is genuinely usable before blaming the diary, because stakeholders skip reviews that give them nothing to react to. Then invite fewer and better people, ask questions that require a decision rather than applause, and be willing to say the review is the wrong forum for this product.
Stakeholder sign-off should not stall a project indefinitely. Confirm the decision owner, shrink the ask, proceed on a dated assumption, and escalate the delivery risk rather than complaining about the person. Use this stakeholder management answer to show the decision, trade-off, and evidence rather than a memorised definition.
Say it does not, then find out what the requirement behind the question is, because what decides the deal is whether the gap blocks them and what the honest path around it costs. A soft yes turns into a contractual obligation that somebody else has to deliver.
Price the whole package before you argue about base, then make one counter that names a specific number, says which components you would take it in, and justifies it against the market for the role rather than your own needs. A sequence of separate asks is what makes a recruiter stop moving.
Scope is the union of the track's sections, the rounds this employer type asks regardless of role, and the industry if you named one. Weights above 1.0 pull a section up the order; below 1.0 push it down. Nothing is excluded - a deprioritised section still appears when its best question is the most relevant thing left.