Interview Preparation for AI Full-Stack Engineers

What to expect#

A four-week plan#

AI system design: a framework#

Design interviews reward structure more than cleverness. Work through these steps out loud, and keep checking with the interviewer:

1. Clarify the problem. Users, scale (requests per day, documents, tenants), latency target, accuracy needs, risk of a wrong answer, budget.
2. Sketch the simplest thing that works. Often a single model call with good context, or a workflow. Say why you are not starting with an agent.
3. Data and context. Where knowledge comes from, how it is indexed (chunking, embeddings, hybrid search), freshness, and access control per user or tenant.
4. Model choice. Capability versus latency versus cost; routing for different request types; caching for repeated context.
5. Actions and safety. Tools, permissions, approvals for risky actions, prompt-injection exposure.
6. Quality. Evals: datasets, graders, what "good" means here, how you would catch regressions.
7. Operations. Streaming, timeouts, retries and fallbacks, observability, cost per request, rate limits.
8. Evolution. What you would build first, what you would measure, what comes next.

Example: "Design a support assistant for a company with 20,000 help articles"#

A strong answer, compressed:

• Clarify: 50,000 conversations per day; answers must cite articles; refunds need human approval; first token under 2 seconds.
• Start simple: RAG over help articles with citations, no actions. Measure deflection rate before adding tools.
• Retrieval: chunk by headings, hybrid search in Postgres with pgvector, rerank the top 20, re-index incrementally on article changes; relevance threshold for "I don't know".
• Model: a mid-size model for most questions, escalation to the most capable model for complex account issues; prompt caching for the system prompt and tools.
• Actions (phase 2): read-only order lookup scoped to the authenticated customer; refunds proposed by the agent and approved by staff; handoff tool.
• Quality: 200 real questions with expected articles (retrieval recall), a judge rubric for answers, behavior cases for tools; thumbs-down feeds the dataset.
• Operations: streaming, 25-second deadline with fallback model, traces with cost per conversation, per-customer rate limits, alert on cost per conversation and handoff rate.

Notice that every choice has a reason and a metric attached. That is what interviewers listen for.

Coding: practice exercises#

AI engineering coding rounds often use practical problems close to the work. Two examples with solutions; try each in 25 minutes before reading the solution.

Exercise 1: top-k similarity search#

Given a query embedding and a list of documents with embeddings, return the IDs of the k most similar documents by cosine similarity. Handle zero vectors and k larger than the list.

export interface EmbeddedDoc {
  id: string;
  embedding: number[];
}
 
function cosine(a: number[], b: number[]): number {
  if (a.length !== b.length) throw new Error(`Dimension mismatch: ${a.length} vs ${b.length}`);
  let dot = 0;
  let na = 0;
  let nb = 0;
  for (let i = 0; i < a.length; i++) {
    dot += a[i]! * b[i]!;
    na += a[i]! * a[i]!;
    nb += b[i]! * b[i]!;
  }
  return na === 0 || nb === 0 ? 0 : dot / (Math.sqrt(na) * Math.sqrt(nb));
}
 
/** O(n log n) for clarity; mention a size-k heap (O(n log k)) or an ANN index for large n. */
export function topK(query: number[], docs: EmbeddedDoc[], k: number): { id: string; score: number }[] {
  if (k <= 0) return [];
  return docs
    .map((d) => ({ id: d.id, score: cosine(query, d.embedding) }))
    .sort((x, y) => y.score - x.score || x.id.localeCompare(y.id)) // stable tie-break
    .slice(0, k);
}

Exercise 2: an incremental SSE parser#

Server-sent events arrive in network chunks that can split anywhere, even inside a line. Write a parser that receives chunks and emits complete events (event and data fields; multiple data lines join with newlines; lines starting with : are comments).

export interface SseEvent {
  event: string;
  data: string;
}
 
export class SseParser {
  private buffer = "";
 
  /** Feed a chunk; returns the events completed by it. */
  push(chunk: string): SseEvent[] {
    // Normalize the whole buffer: a chunk can end between "\r" and "\n".
    this.buffer = (this.buffer + chunk).replace(/\r\n/g, "\n");
    const events: SseEvent[] = [];
    let boundary: number;
    while ((boundary = this.buffer.indexOf("\n\n")) !== -1) {
      const block = this.buffer.slice(0, boundary);
      this.buffer = this.buffer.slice(boundary + 2);
      let event = "message";
      const data: string[] = [];
      for (const line of block.split("\n")) {
        if (line === "" || line.startsWith(":")) continue;
        const colon = line.indexOf(":");
        const field = colon === -1 ? line : line.slice(0, colon);
        const value = colon === -1 ? "" : line.slice(colon + 1).replace(/^ /, "");
        if (field === "event") event = value;
        else if (field === "data") data.push(value);
      }
      if (data.length) events.push({ event, data: data.join("\n") });
    }
    return events;
  }
}

import { test } from "node:test";
import assert from "node:assert/strict";
import { SseParser } from "./lib/sse-parser.ts";
import { topK } from "./lib/top-k.ts";
 
test("topK ranks by cosine similarity and handles edge cases", () => {
  const docs = [
    { id: "a", embedding: [1, 0] },
    { id: "b", embedding: [0.7, 0.7] },
    { id: "c", embedding: [0, 1] },
    { id: "zero", embedding: [0, 0] },
  ];
  assert.deepEqual(topK([1, 0.1], docs, 2).map((r) => r.id), ["a", "b"]);
  assert.equal(topK([1, 0], docs, 10).length, 4);
  assert.deepEqual(topK([1, 0], docs, 0), []);
  assert.throws(() => topK([1, 0, 0], docs, 1), /Dimension mismatch/);
});
 
test("SseParser handles events split across chunks", () => {
  const parser = new SseParser();
  const stream = 'event: text\ndata: {"t":"Hel"}\n\n: keep-alive\n\nevent: text\ndata: {"t":"lo"}\n\nevent: done\ndata: line 1\ndata: line 2\n\n';
  const events = [];
  for (let i = 0; i < stream.length; i += 7) events.push(...parser.push(stream.slice(i, i + 7))); // arbitrary chunk boundaries
  assert.deepEqual(events, [
    { event: "text", data: '{"t":"Hel"}' },
    { event: "text", data: '{"t":"lo"}' },
    { event: "done", data: "line 1\nline 2" },
  ]);
});
 
test("SseParser accepts CRLF line endings", () => {
  assert.deepEqual(new SseParser().push("data: hi\r\n\r\n"), [{ event: "message", data: "hi" }]);
  const split = new SseParser();
  assert.deepEqual([...split.push("data: hi\r"), ...split.push("\n\r\n")], [{ event: "message", data: "hi" }]);
});

What interviewers look for beyond correctness: clarifying edge cases before coding (split chunks, comments, empty data), naming, tests you would write, and the complexity discussion (a heap for top-k; an approximate nearest-neighbor index such as HNSW at scale).

Project deep-dives#

Pick two projects and prepare to go deep for 30 minutes on each. For every project, have crisp answers to:

• What problem does it solve, for whom, and how do you know it works? (Numbers.)
• What was the hardest technical decision, and what were the alternatives?
• What failed or surprised you, and what did you change?
• How does it handle failure: provider outage, bad input, prompt injection, cost spikes?
• What would you change to support 100 times the users?

The case studies from writing about your work are exactly this preparation.

Behavioral stories#

Prepare four or five short stories (a disagreement, a failure, ambiguity, a big impact, learning something fast) in a simple shape: situation, what you did, result, what you learned. Use real numbers and keep each to about two minutes.

Common mistakes#

• Jumping to agents in design rounds. Start simple and justify every added component.
• No metrics. Every design needs a definition of "good" and a way to measure it.
• Ignoring cost and latency. They are first-class requirements for AI systems.
• Coding in silence. Explain your thinking; interviewers grade the process.
• Overselling your projects. Interviewers probe; honest depth beats impressive breadth.

Next steps#