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.
- "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.
- Architecture diagram from memory. Draw the whole system on paper in <90 seconds. If you can't, you don't actually know it.
- Open a random file. Explain it cold. Every function, every import, every decision. No "I'd have to check."
- 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.
- 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.
- Cite one bug + how you found it. Specific, technical, with the actual error message you remember. Generic "it didn't work" answers fail.
- State one thing you'd redo. Honest, specific, learned-from. Not "more tests" — say what specifically.
- 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.
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.
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).
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.
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.
"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.
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."
Literally have the file you're about to discuss already open in a second tab. Searching for files mid-interview kills momentum.
"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.
Daily 5-min drill: pick one decision in your repo. Argue the opposite. If you can defend both directions, you understand the call.
Once. Watch it back. The verbal hesitations and the parts you skip past are exactly where interviewers will probe.
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.