📒 problems 📖 glossary
Mock interview
46:30
ready
of 46:30
Lesson 102 · Behavioral & verbal

Defend every line — your portfolio is the interview

📖 Walk me through it — plain English

This lesson is about a specific kind of job interview round. At many AI-focused companies, instead of (or on top of) the usual whiteboard puzzle, they ask you to screen-share a project you built and talk through it for 45–60 minutes. "Portfolio" here just means the apps you've shipped — your own code, your deployed site, your design notes. The point of the round is to confirm you genuinely built and understand your work, rather than having copied it from a tutorial. So they ask "why" relentlessly: why this database, why this library, what breaks if the AI goes down, what would you change. The lesson's core advice: don't memorize a script of answers — instead, anticipate every "why this and not that?" question, and make sure you know your real reasons cold.

An everyday analogy: imagine you cooked a dish and a chef tastes it, then quizzes you — "Why butter instead of oil? What if you'd used less salt? Which step went wrong the first time?" If you actually cooked it, every answer comes instantly and you can even discuss the version you'd make next time. If you reheated something store-bought, you stall and hand-wave. The interview works exactly the same way: fluent, specific, tradeoff-aware answers prove authorship; vague ones expose that you don't really own the work.

A key term to define: a counterfactual is a "what if you'd done it differently?" question — e.g. "if you started over, what would you change?" Interviewers love these because they test taste (judgment about good vs. bad design), not just whether you can make something run. Another term: tradeoff means every choice gives up one thing to gain another (e.g. a cache makes reads fast but adds the risk of serving stale data). They want to hear that you weighed those, not that you picked at random.

How to prepare, in plain steps:

  • Sketch the whole system from memory in under 90 seconds. If you can't draw the boxes and arrows without notes, you don't know it well enough yet.
  • Open a random file and explain it cold — every function, every imported library — with no "I'd have to check."
  • For each tool you used, have one sentence on why, plus two alternatives you rejected and the reason ("I considered X and Y; chose this because Z").
  • Keep one specific bug story — the real error message and how you tracked it down — and one honest "thing I'd redo."
  • Practice a live edit like "add a rate limit to this endpoint" on your own repo until it's muscle memory, and have the right file already open before the call.
  • Memorize a 30-second pitch per project and a few hard numbers ("$0.18 per 10-min session" beats "cheap"). Numbers read as proof; adjectives read as fluff.

Why this approach works: you can't predict every question, so scripting answers is brittle — one off-script probe and you freeze. But the set of questions ("why this tool, what breaks, what would you change") is predictable. If you rehearse asking yourself those and you know the honest answers, you can respond to anything in the family. "I don't know" once signals humility; the third time in ten minutes signals you don't actually own the system — so the real goal is fluency, and the win is the interviewer leaving convinced you made this.

For AI-native companies (Anthropic, Sierra, Decagon, Cursor, Lovable, founding-eng roles, Palantir-flavored FDE), the resume gets you in the door; the portfolio demo is the actual interview. They want to watch you load up your own code, point at decisions, and explain why-not for every alternative. The candidates who win this round walk in expecting it.

What the round actually is
  • "Walk me through one of your projects." 45–60 min. You drive: screen-share your repo, your deployed app, your architecture doc.
  • Deep follow-ups. "Why FastAPI not Flask?" "Why Redis here, why Postgres there?" "What does this function do?" — pointing at random code.
  • Failure-mode probes. "What happens if the LLM is down?" "What if a user pastes 10MB of input?" "Show me the worst bug you shipped."
  • Counterfactuals. "If you started over today, what would you change?" Strong signal — tests whether you have taste, not just execution.
  • Sometimes a live edit. "Add a rate limit to this endpoint right now." You should be able to.
The defense drill — run per project
  1. Architecture diagram from memory. Draw the whole system on paper in <90 seconds. If you can't, you don't actually know it.
  2. Open a random file. Explain it cold. Every function, every import, every decision. No "I'd have to check."
  3. Name every external dependency and why. "Why slowapi not Flask-Limiter? Why TanStack Query not SWR? Why Render not Fly.io?" Have a 1-sentence answer ready for each.
  4. Name two alternatives you rejected. For every major call. "I considered X and Y; chose this because Z." Tradeoff-fluent is what they're listening for.
  5. Cite one bug + how you found it. Specific, technical, with the actual error message you remember. Generic "it didn't work" answers fail.
  6. State one thing you'd redo. Honest, specific, learned-from. Not "more tests" — say what specifically.
  7. Run the live-edit dry run. Pick a plausible "add X to this code" prompt and time yourself doing it. Practice on your own repo until it's muscle memory.
Your three projects — defense priorities
SoloMock

Lead with this. It's the most interesting + most ambitious + most AI-relevant. Have ready: WebRTC + ephemeral key flow (security narrative), evaluation methodology (how you grade verbal precision), cost per session (Realtime API is not cheap — own the number), why no behavioral chit-chat (product judgment), what you'd do differently.

all-in-one-URL

Lead with for backend roles. Have ready: split stack rationale (FastAPI + React + Postgres + Redis on Render + Vercel + Neon + Upstash), cache invalidation story, OG-image / scrape flow, schema design for analytics, what you'd do differently (probably: monorepo, observability earlier).

swe-interview-guide

The self-aware pick. Have ready: why single-file HTML (constraint-driven design), quiz-gating philosophy, how the content actually pressure-tests pedagogy. Strong meta-signal: candidate who can build, ship, AND reflect on the meta-process of learning to interview.

Memorize the elevator pitch

30 seconds per project. "SoloMock is an AI verbal mock interview app — Realtime API + WebRTC + a Socratic prompt that grades how clearly you explain solutions out loud. Deployed at solomock.com. Built solo in 6 weeks." Practice until it's ambient.

Numbers > adjectives

"Cuts time to first audio from 4s to 800ms" beats "fast." "Costs $0.18 per 10-min session" beats "cheap to run." Memorize a few real numbers per project.

"I don't know" is fine — once

First IDK shows humility. Third IDK in 10 minutes shows you don't own the system. Have a fallback: "I'd have to check the exact value but the order of magnitude is X because Y."

Open the repo before the call

Literally have the file you're about to discuss already open in a second tab. Searching for files mid-interview kills momentum.

Pre-empt the obvious "why"

"You'll notice I used Redis instead of just Postgres — that's for two specific things, rate limiting and OG-scrape caching." Beats waiting for them to ask.

Counterfactual game

Daily 5-min drill: pick one decision in your repo. Argue the opposite. If you can defend both directions, you understand the call.

Record yourself doing the demo

Once. Watch it back. The verbal hesitations and the parts you skip past are exactly where interviewers will probe.

One project should be AI-native

For AI-roles specifically — at least one project must use LLMs as a first-class component, not a footnote. SoloMock qualifies. If you target AI-only roles, build one more.

The winning signal: interviewer leaves thinking "this person made this — they didn't paste it together from tutorials." The way you earn that read is by having a clear, opinionated answer to every "why this and not that." Don't pre-script the answers — pre-script the questions you'd ask yourself, then know your real answers cold.
→ Going deeper: Portfolio narratives often start as take-home projects. See Take-home strategy.