Backend · Frontend · Full-stack · Junior to Staff
Anyone can list interview questions.
These come with the follow-up.
Interview questions written the way senior engineers actually ask them — with the follow-up chain, the failure mode, and what separates a hire from a strong hire.
- Questions
- 498
- Question sets
- 54
- Signal rounds
- 10
- Deep dives
- 7
- Tracks
- 27
Why these are different
Most question lists stop here
Q: What is a database index?
A: A data structure that speeds up lookups by avoiding a full table scan.
True, useless. It survives exactly zero follow-up questions, and every candidate in the pipeline says it.
Every answer here carries five things
- The setup — a real scenario with real numbers, not a definition prompt.
- What they are testing — the signal behind the question, so you answer the right one.
- Weak vs strong — the plausible answer that fails, next to the one that lands.
- The follow-up chain — three or four levels deep, because that is where loops are decided.
- The trap — the confident wrong answer that gets people rejected.
Signal rounds
10 sets, 67 questions, written as an interviewer runs them: a production symptom, a code review, or a decision with no clean answer — then pressure applied until you either have the depth or you do not.
- The AI-assisted coding interview6 scenarios
Google, Meta and others now hand you an AI assistant during the coding round. The rubric changed — here is what is scored and how candidates fail it.
- The incident round6 scenarios
Six production symptoms with no stack trace. The interviewer describes what users see and watches how you narrow it down.
- Distributed correctness6 scenarios
Exactly-once, ordering, clock skew, split brain, and saga rollback — the questions where the confident answer is usually wrong.
- Senior & staff behavioral signal8 scenarios
The behavioral questions that actually decide senior and staff loops — scope, influence without authority, disagreement, and the answers that quietly fail.
- Kubernetes forensics6 scenarios
Six pods that will not run. CrashLoopBackOff, OOMKilled, Pending, ImagePullBackOff, a stuck rollout, and a service returning nothing.
- What does this print?10 scenarios
Ten snippets where the obvious answer is wrong. Predict the output, then explain the mechanism — the explanation is the actual question.
- The code review round7 scenarios
Seven snippets that pass tests and review. Find the bug, name the failure mode, say what you would write instead.
- Frontend forensics6 scenarios
Six frontend symptoms — a render storm, a hydration mismatch only in production, an LCP that is fine in the lab and terrible in the field.
- Query forensics6 scenarios
Six database symptoms — a plan that flipped, an index that made things slower, a lock nobody can find, a migration that took the site down.
- The staff pressure round6 scenarios
Six decisions with no clean answer. The interviewer will disagree with whatever you pick — the question is whether your reasoning survives it.
Deep dives
7 pieces, 59 sections, on how the machinery actually works — the query planner, the interpreter, the render pipeline, the network, the engine, the consensus protocol. This is the layer that lets you keep answering when the interviewer keeps asking "but why?".
- The network path of one request8 sections
DNS, TCP, TLS, HTTP/2 and /3, proxies, keepalive and connection pools — why timeouts, retries and p99 behave the way they do.
- What a container actually is7 sections
Namespaces, cgroups, overlay filesystems, capabilities and seccomp — and why "it works on my machine" still happens.
- From HTML bytes to a painted pixel9 sections
Parsing, style, layout, paint, composite — plus the main thread, the compositor, and exactly where jank comes from.
- How V8 runs your JavaScript8 sections
Parsing, Ignition and TurboFan, hidden classes and inline caches, deoptimisation, and the generational garbage collector.
- How CPython actually runs your code9 sections
Objects, refcounts, the GIL implementation, bytecode and frames, the memory allocator, and what 3.11-3.13 changed.
- What Postgres does with your query10 sections
Parse, rewrite, plan, execute — plus buffers, WAL, MVCC, visibility and locks. The layer beneath every "add an index" answer.
- Replication, consensus & the impossibility results8 sections
How Raft actually works, what quorums buy you, why FLP and CAP constrain everything, and how real databases replicate.
All tracks
Languages
Python
Data model, memory, concurrency, and the runtime behaviour behind production bugs.
6 sets · 55 questions JSJavaScript
Event loop, closures, async semantics, and code that looks right.
5 sets · 48 questions GOGo
Goroutines, channels, context, interfaces, and the concurrency bugs Go makes easy.
1 sets · 10 questions TSTypeScript
Structural typing, generics, narrowing, and where the type system lies to you.
1 sets · 10 questionsBackend
Backend
APIs, idempotency, caching, queues, and designing for the retry.
5 sets · 40 questions DJDjango
Request cycle, middleware, auth, and the settings that cause incidents.
1 sets · 11 questions ORDjango ORM
Querysets, N+1, transactions, and migrations that lock your table.
1 sets · 10 questions FAFastAPI
ASGI, Pydantic, dependency injection, async correctness.
1 sets · 11 questions FLFlask
App and request context, factories, blueprints, WSGI.
1 sets · 10 questions NDNode.js
Event loop phases, streams, cluster vs worker threads, and Express in production.
1 sets · 11 questions GQGraphQL
Schema design, the N+1 resolver, query cost, caching, and when REST is better.
1 sets · 10 questions CECelery & Beat
Acks, retries, idempotency, scheduling, and the duplicate task.
1 sets · 10 questionsData
Frontend
Frontend
HTTP, caching, Core Web Vitals, and making a page measurably fast.
2 sets · 19 questions CSCSS & layout
Specificity, stacking contexts, grid vs flex, container queries, and modern CSS.
1 sets · 10 questions REReact
Reconciliation, hooks, context cost, concurrent rendering, RSC.
3 sets · 27 questions NXNext.js
App Router, server components, four caching layers, server actions.
1 sets · 10 questionsSystems
System Design
Scale, consistency, storage choice, and worked case studies.
4 sets · 29 questions ALDSA
The fifteen patterns, complexity, and how to run the coding round.
2 sets · 24 questions DODevOps & Cloud
Docker, CI/CD, Linux triage, Kubernetes, observability.
3 sets · 23 questions TETesting
What to test where, mocking without lying, killing flaky tests.
1 sets · 10 questions SESecurity
OWASP in practice, auth design, tokens, secrets, SSRF.
1 sets · 10 questionsAI
Craft
Git & workflow
Rebase vs merge, bisect, reflog, conflict recovery, and review hygiene.
1 sets · 10 questions FSFull-stack
End-to-end features, real-time, take-homes, unfamiliar codebases.
1 sets · 9 questions CABehavioral & Career
STAR stories, staff-level signal, negotiation, the offer.
2 sets · 18 questionsHow to use this
No experience yet
Start at the junior sets of one language track and work down. Say your answer out loud before reading ours, then diff the two. The gap is your study list — reading the answer first teaches you almost nothing.
Already working
Go straight to the signal rounds and the senior sets. You probably know the definitions; what gets you the higher band is naming the trade-off, the failure mode, and what you would not do.
Interviewing next week
Follow the 8-week plan compressed: the signal round for your stack, your framework track, one timed system design out loud, and your seven STAR stories written down.