Browse backend interview sets by topic and experience level, reveal what a strong answer looks like, and self-score. Flip to interviewer mode to score a live candidate — notes and verdicts are saved to your device only.
A backend interview question bank with two modes: practice a real mock interview (reveal what strong/adequate/weak answers look like and self-score), or flip to interviewer mode to score a live candidate — notes and verdicts are saved to your device only, never sent anywhere.
1Pick a set from the dropdown. In Practice mode, read a question and click “Reveal model answer” to see the expected answer and the strong / adequate / weak bands.
2To score a real interview, flip the Practice / Interviewer toggle and type the candidate's name (stored only in your browser).
3For each question, tap Green / Middle / Red / Not asked (tap again to clear), and jot notes — the tally bar shows a running “Read”.
4Click Export writeup for a Markdown summary. Use Import set to paste a new question set (or a new topic) as JSON — no rebuild needed.
Pro tips
Keep answer keys collapsed while the candidate is speaking — reveal them only to calibrate your own scoring.
Nothing candidate-specific ever leaves your device: names, verdicts and notes live in this browser's localStorage only.
New sets arrive as JSON you paste via Import — the tool never needs a code change to add questions or candidates.
Practice mode — this is a mock interview set. Reveal a question to see what a strong answer looks like.
Java, Spring Boot, APIs, messaging, distributed systems, production/SRE, leadership, AI, and coding. A full bank to pick from for a 30–45 min screen.
Experience & Candor
4
Which systems on your resume did you personally build, and in which languages? Be specific about your own code vs the team's.
Warm-upHigh signal
Expected answer
A clear, honest split by language and by personal contribution.
What to listen for
StrongNames systems and languages precisely; volunteers non-primary-stack work without being cornered; separates 'I built' from 'my team built'.
AdequateAnswers in generalities but sharpens when pressed.
WeakRounds everything into the target language; can't name one system in another stack despite a public footprint that says otherwise.
Follow-ups
Roughly what's your language split over the last 3 years?
Which did you architect vs maintain?
Where are you strongest in the backend stack, and where are you still growing?
Warm-up
Expected answer
Self-aware map with at least one genuine growth area named unprompted.
What to listen for
StrongSpecific strengths + a real, non-cosmetic weakness.
AdequateStrengths clear; growth area is a humblebrag.
WeakClaims no real gaps.
Follow-ups
What did you last learn from scratch, and how did it go?
Pick a performance/scale metric from your resume. Baseline, exact change, and how you measured it?
High signal
Expected answer
Named bottleneck, concrete change, real measurement (APM, load test, p95/p99 before/after) with numbers.
What to listen for
StrongBaseline + method + numbers + a tradeoff weighed. Hard to fake.
AdequateReal change, fuzzy on measurement.
WeakRound number, no baseline, no method.
Follow-ups
What was p99 before and after?
What did you rule out first?
A technical decision you later regretted, and what you learned?
Expected answer
Specific decision, honest ownership, concrete lesson applied since.
What to listen for
StrongSpecific, self-critical, shows growth.
AdequateGeneric regret with light reflection.
WeakCan't name one, or blames others.
Follow-ups
What would you do differently now?
Java — Language Depth
5
HashMap vs ConcurrentHashMap vs Collections.synchronizedMap — when each?
High signal
Expected answer
HashMap not thread-safe; synchronizedMap locks the whole map; ConcurrentHashMap uses fine-grained locking with far better read concurrency.
What to listen for
StrongExplains lock granularity; picks ConcurrentHashMap for high-read concurrency; knows compound ops still need care.
AdequateKnows HashMap isn't thread-safe, hazy on the rest.
WeakThinks HashMap is thread-safe or can't differentiate.
Follow-ups
Is check-then-put on ConcurrentHashMap atomic? How do you fix it?
Explain the equals()/hashCode() contract. What breaks if you get it wrong?
Expected answer
Equal objects must have equal hashCodes; violate it and HashMap/HashSet lookups fail silently.
What to listen for
StrongStates the contract and the concrete collection failure.
AdequateKnows == vs equals, vague on hashCode consequences.
WeakConfuses == and equals.
Follow-ups
Can two unequal objects share a hashCode — is that OK?
What's a memory leak in a GC language like Java? A real cause, and how you'd find it.
StrongCorrect mental model + a real use case for each.
AdequateKnows both are 'queues', blurs the difference.
WeakTreats them as interchangeable.
Follow-ups
Which for event sourcing, which for a job queue?
Kafka: how is ordering guaranteed, and how do partitions and consumer groups interact?
High signal
Expected answer
Ordering only within a partition (by key); one partition → one consumer per group; parallelism bounded by partition count.
What to listen for
StrongOrdering-per-partition + the partition/consumer math.
AdequateKnows partitions exist, unclear on ordering.
WeakBelieves there's global ordering across a topic.
Follow-ups
You need per-customer ordering — how do you partition?
At-least-once vs exactly-once — how do you handle duplicate processing?
High signal
Expected answer
Most systems are at-least-once → idempotent consumers (dedupe key, upsert); mind offset-commit timing; exactly-once is costly/limited.
What to listen for
StrongReaches for idempotent consumers + offset-commit tradeoff.
AdequateKnows duplicates happen, no concrete strategy.
WeakAssumes exactly-once for free.
Follow-ups
Commit the offset before or after processing?
A consumer group is lagging badly. Causes and response?
Expected answer
Slow processing, too few partitions, poison message, downstream slowness, rebalancing. Response: scale consumers to partition count, profile the handler, add a DLQ.
2 AM: p99 latency jumped 200ms → 4s. No deploy went out. First 15 minutes?
High signal
Expected answer
Golden signals (latency/traffic/errors/saturation) → traffic changes → DB (slow queries, locks, pool) → downstream deps → GC/thread dumps → resource limits. Communicate + mitigate before RCA.
What to listen for
StrongStructured triage, forms hypotheses, mitigates first.
AdequateSome steps but jumps to a random guess.
Weak'Restart the server' first, no diagnosis.
Follow-ups
Nothing deployed — what external things still change at 2am?
Connection pool exhaustion under load. Cause and fix?
Expected answer
Leaked/unclosed connections, long transactions, undersized pool, slow queries holding connections. Fix: find the leak, size to DB limits, add timeouts, tighten @Transactional scope.
What to listen for
StrongDistinguishes leak vs sizing; checks query duration; sets timeouts.
Adequate'Increase pool size' only.
WeakDoesn't know what a connection pool is.
Follow-ups
Why can raising the pool size make it worse?
What goes on a service dashboard, and what do you alert on?
Expected answer
Golden signals + key business KPIs; alert on symptoms / SLO burn, not raw CPU; avoid alert fatigue.
What to listen for
StrongSLO-driven alerting on symptoms.
AdequateLists CPU/memory only.
Weak'We check logs when someone complains.'
Follow-ups
Why is alerting on CPU usually a bad idea?
Leadership
3
Mentoring a struggling engineer — what you did and the outcome.
Expected answer
A specific person, a specific intervention, a measurable change, self-reflection.
What to listen for
StrongConcrete story, ownership, real growth.
AdequateGeneric 'I pair and review'.
WeakBlames the engineer.
Follow-ups
What if it hadn't worked?
Delivery pressure vs code quality — a real call you made as a lead.
Expected answer
Named the tradeoff, took on debt deliberately, logged it, paid it down.
What to listen for
StrongNuanced and specific.
AdequateLeans one way with light reasoning.
WeakAbsolutes either way.
Follow-ups
How did you make the debt visible?
A disagreement with another senior engineer or architect — how did it resolve?
Expected answer
Focused on the problem, used data/prototypes, disagreed-and-committed where needed.
What to listen for
StrongHandles conflict on substance, not ego.
AdequateResolved but one-sided.
WeakAlways yields or never yields.
Follow-ups
What if the decision went against you?
AI & Developer Productivity
9
Walk me through an AI/RAG system you've built end to end — embeddings, chunking, retrieval, generation.
High signal
Expected answer
Embed docs → chunk with overlap → vector store → similarity search on the query → inject context into the prompt → generate → return. Justifies chunk size and embedding model.
What to listen for
StrongExplains each stage AND chunking/eval decisions AND a real limitation hit.
AdequateDescribes the happy path, shaky on chunking/eval.
WeakBuzzword chain; can't explain what an embedding is.
Follow-ups
How did you pick chunk size and overlap?
How did you know retrieval returned the right context?
What is an embedding, really — and how does similarity search use it?
High signal
Expected answer
A vector representation of meaning; similar text → nearby vectors; search ranks by cosine/dot-product distance.
What to listen for
StrongClear, correct, intuitive.
AdequateRoughly right, hand-wavy on the metric.
WeakCan't explain beyond 'it's how AI understands text'.
Follow-ups
Cosine vs Euclidean — does it matter here?
Vector DB choice — Chroma vs pgvector vs a hosted option. Tradeoffs?
Expected answer
Chroma = light, fast to prototype; pgvector = reuse Postgres, transactional, simpler ops; hosted = managed scale but cost + lock-in.
What to listen for
StrongReasons from scale, ops burden, existing stack.
AdequateNames one with a shallow reason.
WeakDoesn't know what a vector DB is for.
Follow-ups
At 100M vectors, what changes?
An LLM needs to safely use internal tools/actions (an agent). How do you design that?
High signal
Expected answer
Tool/function calling with tight scopes; validate inputs AND outputs; least privilege; human-in-the-loop for risky actions; guardrails; an eval harness. MCP-style interfaces a plus.
What to listen for
StrongThinks about tool boundaries, validation, permissions, evaluation — not just prompting.
AdequateEnthusiastic but only prompt-level.
WeakNo concept of scoping or blast radius.
Follow-ups
The model calls a delete tool with bad args — what stops damage?
How do you know an AI feature is good — and stays good as you change prompts/models?
Expected answer
Eval sets, golden examples, offline evals + human review, prompt regression tests, production monitoring.
What to listen for
StrongHas an actual eval discipline.
Adequate'I test it manually.'
WeakNo notion of measuring quality.
Follow-ups
You swap the model — how do you catch a regression?
What causes hallucinations, and how do you reduce them in a RAG app?
Expected answer
Model fills gaps without grounding; reduce via good retrieval, grounding the prompt, citing sources, letting it say 'I don't know', constraining scope.
What to listen for
StrongTies hallucination to weak retrieval/grounding + concrete mitigations.
AdequateKnows the term, generic mitigation.
WeakThinks a bigger model just fixes it.
Follow-ups
Retrieval returns nothing relevant — what should the app do?
What's a context window, and what breaks when you exceed it?
Expected answer
Token budget for input+output; exceed it and content is truncated/dropped or the call fails; manage via chunking, summarization, retrieval.
What to listen for
StrongCorrect + names real strategies.
AdequateVaguely 'the memory of the model'.
WeakNever heard of it.
Follow-ups
Why not paste a 500-page manual in?
AI-generated code in your team's workflow — how do you keep it safe?
Expected answer
Treat it like a junior's PR: human review before merge, tests, static analysis, never paste secrets/proprietary code into external tools.
Design an AI assistant that answers questions over our internal docs. Walk the request path and where it can go wrong.
SeniorHigh signal
Expected answer
Retrieve relevant chunks (embed the query -> vector search) -> assemble a grounded prompt with citations -> call the model -> validate/post-process -> return with sources. Failure points: poor retrieval, stale index, prompt injection from the docs, hallucination when context is thin, latency/cost.
What to listen for
StrongTraces the whole path AND names concrete failure modes with a mitigation for each (grounding, citations, 'I don't know', injection filtering).
AdequateDescribes the RAG happy path but is thin on failure modes.
Weak'Just send the question to the LLM' - no retrieval or grounding.
Follow-ups
How do you stop a malicious doc from hijacking the assistant?
How do you keep answers current as docs change?
An assistant needs to take actions (create tickets, issue refunds) via tools. How do you make that safe?
Architect / LeadHigh signal
Expected answer
Tool/function calling with tight schemas; validate inputs AND outputs; least-privilege scope per tool; human-in-the-loop confirmation for irreversible or high-value actions; rate/spend caps; a full audit log; an eval harness for tool selection.
What to listen for
StrongReasons about blast radius: scoping, confirmation gates, idempotency, auditability - not just prompting.
AdequateMentions function calling but hand-waves permissions and guardrails.
WeakGives the model broad access and trusts the prompt to keep it in line.
Follow-ups
The model calls refund with the wrong amount - what stops the damage?
Which actions need a human in the loop, and why?
How do you evaluate an AI assistant's quality and catch regressions when you change the prompt or model?
Senior
Expected answer
A golden eval set of representative inputs with expected properties; automated offline evals (exact / semantic / LLM-as-judge) plus human spot-checks; prompt and model regression runs in CI; production monitoring (thumbs, escalations, groundedness).
What to listen for
StrongHas an actual eval discipline tied to releases, not vibes.
Adequate'I test some prompts manually' - no harness.
WeakNo notion of measuring quality or catching regressions.
Follow-ups
You swap Haiku for Sonnet - how do you know nothing regressed?
How do you manage context and memory in a multi-turn assistant without blowing the context window or the budget?
Senior
Expected answer
Summarize/trim old turns, retrieve only relevant history, cap tokens, keep a rolling summary plus a retrieval store for long-term memory, and stream. Separate short-term conversation memory from long-term (vector) memory.
What to listen for
StrongSeparates conversation memory from retrieved long-term memory and manages the token budget deliberately.
AdequateKnows the window is finite but is vague on strategy.
WeakPastes the whole history every turn.
Follow-ups
Turn 50 of a chat - what is actually in the prompt?
AI Engineering on the JVM
6
You put an LLM into a Spring Boot service with Spring AI / LangChain4j. Java request threads block, the model is slow, and it streams tokens. How do you design the call path — threading, timeouts, backpressure, and streaming to the client?
Architect / LeadHardHigh signal
Expected answer
Don't hold a servlet thread for the whole generation. Reactive (WebFlux/Flux) or a bounded, ISOLATED executor for LLM calls so a slow model can't starve the request pool; stream to the client via SSE/Flux; per-call timeout + circuit breaker / fallback (resilience4j); bounded concurrency + queue.
What to listen for
StrongNames streaming (SSE/reactive) AND thread-pool isolation AND timeout/circuit-breaker AND a real incident (thread starvation, timeout tuning, token backpressure).
AdequateKnows to make it async and stream, but is vague on pool isolation or failure handling.
WeakWould call the model synchronously on the request thread; no timeout or streaming story.
Follow-ups
Where does the LLM call's thread pool live, and why separate it from the request pool?
The model takes 40s or errors mid-stream — what does the user see?
You've used FAISS in one project and Pinecone in another, plus Elasticsearch kNN. Walk me through when each is the right choice — persistence, scale, ops burden, and cost.
Architect / LeadHardHigh signal
Expected answer
FAISS = in-process library, fastest, no network hop, but YOU own persistence/replication/sharding — ephemeral unless you snapshot; good single-node/batch. Pinecone = hosted/managed scale + replication, network hop + recurring cost; good when you don't want to run infra. ES kNN = reuse an existing ELK cluster, hybrid keyword+vector; good if you already run ES. Chooses on ops capacity vs cost vs latency.
What to listen for
StrongCorrectly frames FAISS as embedded/no-built-in-persistence, Pinecone as managed-but-paid, ES as hybrid/reuse — AND picks by team ops capacity + scale, with a real tradeoff they hit.
AdequateKnows FAISS is local and Pinecone hosted; fuzzy on persistence or hybrid search.
WeakTreats them as interchangeable; can't state that FAISS has no built-in persistence.
Follow-ups
The FAISS process restarts — what happens to your index?
When would you just keep vectors in Postgres/pgvector instead of any of these?
Your agent can query internal relational databases and call external APIs to 'execute backend tasks.' In a bank, how do you stop it from doing something catastrophic — a destructive query, a wrong refund?
Architect / LeadHardHigh signal
Expected answer
Treat the LLM as untrusted. Least-privilege scoped creds (read-only where possible), ALLOW-LISTED tools/actions — never raw generated SQL, validated/parameterized tool inputs, impact/spend limits, human-in-the-loop approval for irreversible actions, dry-run + idempotency keys, and a full audit log of every tool call + the plan.
What to listen for
StrongMultiple independent guards (scoped perms + allow-listed tools + human approval + audit) AND explicitly treats the model output as untrusted AND a real safeguard they built.
AdequateMentions permissions and a human check but misses audit / idempotency / allow-listing.
WeakTrusts the model to behave; would let it run model-generated SQL directly against a DB.
Follow-ups
The agent proposes a DELETE — what must be true before it runs?
How do you make a tool call idempotent AND auditable?
You send customer financial data to a hosted model (OpenAI / Vertex). What's your data-governance and PII story — what leaves the building, and what never does?
Architect / LeadHardHigh signal
Expected answer
Minimize + redact/tokenize PII before egress; enterprise/regional endpoints with no-training/no-retention terms (or self-host the most sensitive); DLP on prompts; per-field classification of what's allowed out; encryption in transit; DPA/contractual controls; often keep retrieval/embeddings internal so raw records never leave. Knows the regulatory frame (GLBA/PCI).
What to listen for
StrongRedaction/tokenization + no-retention enterprise terms + a clear 'this class of data never leaves' line + names the compliance regime.
AdequateSays 'we mask PII' and 'we have an enterprise agreement' but can't describe the concrete pipeline.
WeakHadn't considered it; would send raw customer records to a public API.
Follow-ups
Which fields are you willing to send, which never?
How do you prove to an auditor exactly what was sent to the model?
You built an AI email/SMS classification microservice with Vertex AI. When do you prompt an LLM vs fine-tune vs use a classical model — and how do you measure it and catch drift over time?
Architect / LeadMedium
Expected answer
Classical/small model when labels are plentiful and latency/cost matter (cheap, fast, deterministic); prompt an LLM for cold-start / few labels / flexible categories; fine-tune when you have data and need better accuracy+cost than prompting at scale. Measure on a labeled eval set: precision/recall/F1 per class + confusion matrix; monitor input distribution + per-class metrics in prod for drift; low-confidence to a human review queue.
What to listen for
StrongPicks by data-availability + cost/latency AND names real metrics (F1 / confusion matrix) AND a drift-monitoring + relabel loop.
AdequateKnows the LLM-vs-classical tradeoff but is vague on metrics or drift.
WeakDefaults to 'use an LLM for everything'; no eval or metrics.
Follow-ups
How big does the labeled set need to be to justify fine-tuning?
How do you notice the model degrading before customers do?
You store text embeddings alongside your SQL data. pgvector in Postgres vs a separate vector store — and when a source row changes, how do you keep its embedding in sync?
Architect / LeadMedium
Expected answer
pgvector when you want transactional consistency, one system to operate, and moderate scale — embedding lives with the row and is updated in the same write path. Separate store when scale/ANN needs exceed Postgres. Sync: re-embed on write via trigger or an outbox/CDC (Kafka) event; version/timestamp embeddings; backfill job after a model change. Never let the embedding silently drift from the source text.
What to listen for
StrongChooses by consistency + scale AND gives a concrete re-embed-on-change mechanism (outbox/CDC/trigger) AND handles backfill/versioning after a model swap.
AdequatePrefers pgvector for simplicity but hand-waves the sync ('we re-run a job sometimes').
WeakEmbeds once and has no plan for updates — stale embeddings that no longer match the row.
Follow-ups
The source text is edited — what triggers the re-embed, and is it in the same transaction?
How do you backfill after switching the embedding model?
Coding Round
2
Return the 2 most frequent words in a string. Then discuss time complexity, edge cases, and rewrite the ranking WITHOUT streams.
Coding · primaryHigh signal
Expected answer
Tokenize → HashMap frequency count → find top 2 (sort entries, or a bounded min-heap/single pass). O(n) count; O(n log n) sorting or O(n log k) heap. Edge cases: empty, ties, punctuation, case, <2 distinct words.
What to listen for
StrongReaches for a HashMap naturally; states complexity before you ask; handles case/punctuation; rewrites ranking imperatively; talks edge cases unprompted.
AdequateWorks but only via streams; can't easily do it without them; needs prompting for complexity.
WeakCan't structure the count; complexity contradicts the code.
Follow-ups
Now top-K where K is a parameter.
Now without a HashMap.
Input is 50 GB and won't fit in memory — approach?
Write a thread-safe counter that many threads increment. Then say what's wrong with the naive version.
Coding · concurrency tell
Expected answer
Naive HashMap + count++ isn't atomic → race. Use ConcurrentHashMap.merge/compute, or AtomicInteger/LongAdder. Explain why a synchronized map still fails for compound ops.
What to listen for
StrongSpots the race immediately; right concurrent primitive; explains why synchronizedMap isn't enough for read-modify-write.
AdequateWraps everything in one big synchronized block — works, not ideal.
WeakSees no problem — strong signal Java concurrency is surface-level.
Follow-ups
Why isn't synchronizedMap enough?
AtomicInteger vs LongAdder under heavy contention?
Prepping for backend/AI roles? MindloomHQ teaches you to build real agentic systems — with projects, feedback, and certificates.