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?
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.