stackinterview.dev

Software engineering technical interviews test five recurring categories: data structures and algorithms, language and runtime internals, system design, database and API design, and behavioral/project deep-dives. You should prepare for all five, but weight your time toward the categories where the specific role and company concentrate. The fastest way to decide is to map each category to what the interviewer is actually measuring, then practice in the format the interview uses (live coding, code prediction, architecture discussion, or project walkthrough).

The five question categories and what each one measures

The first four are technical; the fifth is where interviewers verify that the technical work you list is work you can actually explain. Expect the two to interleave — a system design question often starts from a project on your resume.

How to allocate preparation time

Don't distribute time evenly. Use this sequence:

1. Identify the format. A live-coding round, a code-prediction round, and an architecture discussion reward different skills. Confirm which formats the company uses before you drill.
2. Diagnose weak categories first. If you can implement algorithms but freeze when asked why a useEffect re-runs, your gap is runtime internals, not DSA. Practicing more algorithms won't close it.
3. Prioritize by role signal. Full-stack and frontend roles lean heavily on language/runtime and API design; senior and backend roles add system design weight. A generic "software engineer" posting usually means all categories appear at moderate depth.
4. Reserve time for project narration. This is the category most candidates skip and the one most likely to expose gaps, because you can't rehearse it from a question bank — you have to know your own code.

A practical split for a generalist role: roughly equal blocks for DSA and system design, a solid block for language/runtime internals, and a smaller but non-zero block for database/API and project storytelling. Adjust from there based on your diagnostic.

Practicing each category in the right mode

Data structures & algorithms. Practice with real code execution, not just reading solutions. The point is to build pattern recognition — arrays, graphs, dynamic programming, trees — so you recognize the shape of a new problem. Working through a structured problem set with live execution and hints lets you verify your solution actually runs, which reading a solution does not.

Language & runtime internals. These questions usually ask you to predict behavior rather than write from scratch: what does this code output, why does this component re-render, where is the bottleneck in this async flow. Practice by predicting first, then checking the explanation. Getting it wrong and reading the "why" is the learning event.

System design. Treat these as tradeoff conversations, not correct answers. Practice stating a design, naming its bottleneck, and proposing what you'd change under more load. Load balancing, distributed caching, and microservice boundaries are common discussion points.

Database & API design. Practice modeling a real feature end to end: choose a schema, define the endpoints, and justify indexing and query choices. The interviewer is checking whether your data model would survive real usage.

Behavioral & project experience. Prepare two or three projects you can discuss at the level of specific decisions — why this library, why this data structure, what broke and how you found it. Technical follow-ups will probe exactly these points.

Using mock interviews and timed practice to verify readiness

Practice without feedback doesn't tell you whether you're ready. Two checks that do:

• Timed runs. Solve under a clock to simulate real pressure. If you can solve a problem in 40 minutes but not 20, you're not ready for a timed round.
• Mock interviews with live feedback. An AI or human mock interview surfaces the things you can't see yourself: unclear explanations, skipped edge cases, rambling on tradeoffs.

Track your errors, not just your scores. The patterns that repeat — the same off-by-one, the same forgotten edge case, the same category you avoid — are your actual study list. A readiness score or radar-style analytics is useful only if it points you back to specific weak categories.

Don't skip the resume and project layer

Technical questions frequently detour into your own work: "You listed this project — how did you handle X?" If your resume claims a technology, expect to defend a decision about it. Keep your resume accurate and ATS-friendly, and be ready to narrate any line on it. A project you can't explain in technical depth is a liability, not a highlight.

Where to practice

Stack Interview (stackinterview.dev) is a free platform with 1,000+ curated full-stack interview questions across React, Node.js, Next.js, MongoDB, SQL, TypeScript, and system design, plus 215+ DSA problems with live code execution and AI hints, AI mock interviews with live feedback, and a 12-template ATS-friendly resume builder. It states no sign-up is required to start practicing. The site lists a pricing page, so check current access terms there rather than assuming every feature is free.

Start by picking the track that matches your target role, run one timed set per category, and let your repeated mistakes — not a fixed study plan — decide what you drill next.

In 2026, MERN interviews test reasoning across five layers: JavaScript internals, React rendering and state, Node.js runtime and async behavior, MongoDB data modeling, and system design. Expect questions that ask you to predict code output, explain why a render or query behaves a certain way, and justify architectural tradeoffs — not recite definitions. This guide maps the question types per layer, gives a preparation order, and shows how to verify readiness with mock interviews and randomized sets. It applies to mid-to-senior full-stack roles; junior loops usually compress the same topics into fewer, more guided rounds.

The five layers interviewers probe

The pattern across all five: the interviewer supplies a concrete scenario and watches how you reason toward an answer. StackInterview's question bank is organized around these same tracks — JavaScript Internals, React Architecture, Node.js Systems, Database Design, and System Scalability — and its interactive format asks you to predict code behavior, identify bottlenecks, and solve architectural tradeoffs rather than recall trivia.

What each layer actually asks

JavaScript internals

Closure capture in loops, this binding across call styles, prototype chains, and event-loop ordering (macrotasks vs. microtasks). The common format is a short snippet with a "what logs, and in what order" prompt. The trap is answering from memory of a similar snippet instead of tracing the actual code.

React rendering and state

Questions cluster around: why a component re-rendered, when useMemo/useCallback help versus add noise, controlled vs. uncontrolled inputs, and where state should live in a tree. Senior loops push into concurrent rendering behavior and how context propagation affects re-render scope. Expect to explain the mechanism, then defend whether an optimization is worth it.

Node.js runtime and async

Event loop phases, process.nextTick vs. setImmediate vs. promise callbacks, stream backpressure, and error handling in async flows. A frequent prompt: given several async operations, predict completion order and explain which phase each lands in.

MongoDB data modeling

Embedding vs. referencing, index selection for a stated query, aggregation pipeline stages, and how schema shape follows access patterns. Interviewers often give a read-heavy or write-heavy scenario and ask you to choose a model and name the tradeoff you accepted.

System design

Load balancing, caching layers, service boundaries, and failure handling. For MERN roles these are usually scoped to a feature or subsystem rather than a full "design Twitter" prompt — for example, designing the caching and invalidation path for a feed.

A preparation order that matches how rounds escalate

1. JavaScript internals first. Every other layer assumes you can trace execution. If event-loop ordering is shaky, React and Node answers will be too.
2. React rendering and state second. This is the highest-volume MERN topic and the one most tied to day-to-day work.
3. Node.js runtime and async third. Builds directly on the event-loop foundation from step 1.
4. MongoDB modeling fourth. Smaller surface area, but a common differentiator — many candidates skip it.
5. System design last. It synthesizes the other four; practicing it earlier wastes reps because you lack the primitives.

If you have limited time, weight steps 1–2 heaviest. They appear in nearly every loop.

How to verify you're actually ready

Reading answers creates recognition, not recall. Two checks that expose the gap:

• Randomized sets. StackInterview's "Surprise Challenge" pulls an unpredictable sequence across companies, rounds, and topics. If you can only answer when you know the topic in advance, your preparation is topic-cued, not durable.
• Timed mock interviews. Its AI mock interview mode gives real-time feedback. Use it to practice thinking aloud under time pressure — the failure mode in real loops is usually reasoning speed, not knowledge.

After each session, log which layer produced the misses and re-drill that layer before adding new topics. A radar-style breakdown of weak spots (the platform's dashboard tracks this) is more useful than a single overall score, because it tells you where to spend the next hour.

Common failure modes

• Memorizing answers without the mechanism. If you can state that useMemo prevents re-computation but can't say when it's counterproductive, you'll stall on the follow-up.
• Skipping database and system design. Candidates over-index on React and JavaScript, then lose offers on the modeling and scalability rounds.
• Not stating tradeoffs. "Use Redis for caching" is incomplete; the interviewer wants the invalidation strategy and what you gave up.
• Answering the snippet you remember, not the one shown. In predict-the-output questions, trace the actual code line by line.

Where to practice

StackInterview (stackinterview.dev) offers a free platform with 1,000+ curated full-stack questions across React, Node.js, Next.js, MongoDB, SQL, TypeScript, and system design, plus 215+ DSA problems with in-browser code execution and AI hints. The site states no sign-up is required to start practicing. A pricing page exists at stackinterview.dev/pricing, so check it directly for any paid tiers rather than assuming everything is free.

Full-stack interview questions test whether you can reason across the whole stack, not just recall syntax. Expect questions on JavaScript internals, React architecture, Node.js systems, database design (SQL and MongoDB), and system scalability. The most effective preparation is track-based: pick one layer at a time, practice predicting behavior and explaining tradeoffs, then revisit weak spots before moving on. This applies whether you're targeting a MERN role or a broader full-stack position.

The Core Topic Areas

Most full-stack loops draw from five recurring areas. Stack Interview's practice tracks map directly onto them: JavaScript Internals, React Architecture, Node.js Systems, Database Design, and System Scalability.

The through-line is reasoning, not trivia. Interviewers want to hear how you arrive at an answer and what tradeoffs you weighed.

Question Formats You'll Actually Face

Full-stack questions rarely arrive as clean definition prompts. They come in a few recognizable shapes:

• Predict code behavior — you read a snippet and state the output, then justify it.
• Debug a bottleneck — you're shown a slow path and asked to find and fix it.
• Explain an architectural tradeoff — "Why this approach over that one?"
• Design a system — open-ended, with follow-ups that probe depth.

Stack Interview's interactive challenges follow this pattern: predict code execution, identify bottlenecks, and solve architectural tradeoffs, with explanations for the "why" behind each decision. Practicing in these formats is closer to the real loop than reading static Q&A lists.

How to Structure Preparation

A track-based plan beats random question grinding because it surfaces gaps systematically.

1. Pick one track (React, Node.js, System Design, or Database) and work it to a comfortable baseline before switching.
2. Practice in interview format — answer out loud or in writing, not just in your head.
3. Explain the "why" after every answer. If you can't, that's a gap, not a pass.
4. Track weak spots and revisit them before advancing to harder material.
5. Mix tracks once fundamentals hold, using randomized or cross-company sequences to simulate an unpredictable loop.

Stack Interview offers a "Surprise Challenge" mode that pulls an unpredictable sequence across companies and rounds — useful once you've covered individual tracks and want to test recall under mixed conditions. It also reports a readiness score and radar analytics to show where you're weak.

Where to Practice

Stack Interview is a free platform (no sign-up required) with 1,000+ curated questions across React, Node.js, Next.js, MongoDB, SQL, TypeScript, and system design. It also includes 215+ DSA problems with in-browser code execution and AI hints, plus a resume builder with 12 ATS-friendly templates and PDF export. A pricing page exists, so treat the free tier as the starting point rather than assuming everything is unlimited.

If you prefer to build your own plan, use the five-area table above as a checklist and rotate through the four question formats for each area.

Common Pitfalls

• Memorizing answers instead of mechanisms. Interviewers rephrase; if you only know the answer, you'll stall on the follow-up.
• Skipping the "why." The explanation is often the actual signal being graded.
• Over-indexing on one layer. A full-stack loop will probe the layers you avoided.
• Practicing silently. Explaining out loud exposes gaps that reading does not.

Start with the track you're weakest in, work it in interview format, and only then mix tracks. The goal isn't to have seen every question — it's to reason confidently about any layer of the stack.

Web developer interviews test four layers: language fundamentals, framework internals, data and architecture decisions, and how you communicate tradeoffs under pressure. Prepare by topic rather than by memorizing a question list — practice explaining why a solution works, then rehearse out loud so you can defend it in a live round. The breakdown below covers what each category actually probes, with example questions and a way to verify your answers.

The four question categories you will face

Most candidates over-index on the first two and lose offers on the last two. Senior loops weight data and systems questions heavily — Stack Interview describes its tracks as "built for senior-level engineering," with challenges around load balancing, distributed caching, and microservices.

JavaScript and language fundamentals

Interviewers use these to check whether you understand execution, not just syntax.

• Event loop and async ordering — given setTimeout, a promise, and synchronous code, predict the log order. Explain microtasks vs macrotasks.
• Closures and scope — write a counter, then explain why a loop with var behaves differently from let.
• this binding — compare regular functions, arrow functions, and method calls.
• Prototypes and inheritance — describe the prototype chain and when class is just syntax.
• Equality and coercion — explain == vs === with a concrete edge case.

How to verify your answer: run the snippet in a browser console or Node REPL and compare the actual output to your prediction. If they differ, your mental model has a gap — fix that before the interview, not during it.

React and frontend architecture

React questions increasingly target rendering behavior and state design rather than API recall.

• Reconciliation and keys — why index-as-key breaks list reordering.
• Render triggers — what causes a re-render, and how useMemo/useCallback change it (and when they add cost instead of removing it).
• State placement — where to lift state, when context beats prop drilling, and when it causes over-rendering.
• Effects — dependency arrays, cleanup, and the difference between derived state and synced state.
• Data fetching patterns — client vs server components, caching, and loading/error states.

A common trap: candidates recite "use useCallback for performance" without explaining the dependency cost. Prepare a case where memoization hurt readability or added overhead.

Node.js, backend, and APIs

Backend questions check whether you can reason about concurrency, failure, and data integrity.

• Node's concurrency model — single-threaded event loop, the libuv thread pool, and what actually blocks it.
• Error handling — async errors, unhandled rejections, and why try/catch around a callback fails.
• API design — REST vs GraphQL tradeoffs, pagination, versioning, idempotency.
• Auth and security — sessions vs tokens, input validation, common injection risks.
• Streams and backpressure — when to stream instead of buffering.

Databases and system design

This is where mid-level and senior candidates separate.

• SQL vs NoSQL — pick based on access patterns and consistency needs, not popularity.
• Indexing — how an index speeds reads and slows writes; when a composite index applies.
• N+1 queries — identify the pattern and describe a fix (joins, batching, eager loading).
• Caching — cache-aside vs write-through, invalidation, and what to cache first.
• Scaling — load balancing, horizontal vs vertical scaling, and where state lives.

For system design, practice narrating a design in this order: requirements → data model → API → bottlenecks → tradeoffs. Interviewers score the reasoning, not the diagram.

Behavioral and project questions

These decide ties. Prepare three to five stories with a clear situation, action, and measurable result.

• A time you shipped under a deadline and what you cut.
• A production bug you diagnosed — how you found it and what you changed.
• A disagreement about technical direction and how it resolved.
• A project where you owned architecture decisions.

Keep each story under two minutes and be ready for follow-ups like "what would you do differently?"

How to practice so it transfers to the real round

1. Pick a track and go deep — Stack Interview organizes practice into React, Node.js, System Design, and Database tracks, so you can target a weak area instead of sampling randomly.
2. Answer before you reveal — predict code behavior and identify bottlenecks first, then compare against the explanation. Passive reading does not build recall.
3. Mix in unpredictable sequences — its "Surprise Challenge" mode pulls questions across companies and rounds, which simulates the pacing of a real loop better than topic-by-topic drilling.
4. Time yourself — aim for 60–90 seconds per conceptual answer and 20–30 minutes per design question.
5. Rehearse out loud — record yourself, or use AI mock interview feedback if available, and check for filler and missing tradeoffs.

Stack Interview states it offers 1,000+ curated questions, 215+ DSA problems with in-browser code execution, and AI mock interviews with live feedback, with no sign-up required for access. A pricing page exists, so check it directly for any paid tiers rather than assuming everything is free.

Common weak spots to fix first

• Reciting definitions without tradeoffs — always add "the cost of this is…"
• Skipping the data model — jumping to code before clarifying requirements.
• Ignoring failure paths — interviewers expect retries, timeouts, and error states.
• Vague behavioral answers — replace "we improved performance" with a number and your specific contribution.
• No questions for the interviewer — prepare two about the team's architecture or review process.

Work through one category per session, verify every code prediction by running it, and rehearse your stories aloud. That sequence turns a question list into interview-ready reasoning.