The full stack interview roadmap

var, let, const and the temporal dead zone

Why does reading a `let` before its declaration throw, while `var` gives undefined?

Hoisting — variables, functions, classes

What exactly gets hoisted, and what does not?

Primitives vs reference types

Is JavaScript pass-by-value or pass-by-reference? Defend your answer.

Type coercion, == vs ===, truthy and falsy

Predict the output: `[] == false`, `null == undefined`, `NaN == NaN`

typeof, instanceof, Array.isArray, Object.prototype.toString

Why is `typeof null` object, and how do you reliably detect an array?

Destructuring — object, array, nested, defaults, rest

Swap two variables without a temp; pull a nested value with a default.

Spread vs rest; shallow vs deep copy

Why does spreading a nested object still share references?

Optional chaining, nullish coalescing, logical assignment

When does `??` behave differently from a plain OR?

Template literals and tagged templates

Strict mode — what it actually changes

Number precision, 0.1 + 0.2, Number.EPSILON, BigInt

Why is `0.1 + 0.2 !== 0.3` and how do you compare floats safely?

JSON.stringify and parse — replacer, reviver, what is lost

What happens to undefined, functions, Symbols and circular refs?

Symbols and well-known symbols

What does `Symbol.iterator` let you do?

Labeled statements, switch fallthrough, comma operator

Lexical scope and the scope chain

Closures — definition, uses, memory cost

Explain a closure to someone who has never heard the word.

The classic loop + setTimeout puzzle

Why does a `var` loop print 3,3,3 and `let` print 0,1,2? Fix it three ways.

this — default, implicit, explicit, new, arrow binding

What is `this` inside a method passed as a callback, and how do you fix it?

call, apply, bind — and implement your own bind

Write `Function.prototype.myBind` supporting partial application.

Arrow functions vs regular functions

Name four concrete differences. When must you NOT use an arrow?

Practical closures: once, memoize, counter, private state

Implement `memoize(fn)` with a cache key strategy.

Currying and partial application

Implement `curry(fn)` and infinite currying `sum(1)(2)(3)()`.

IIFE and the module pattern

Function composition and pipe

Implement `pipe(...fns)` and `compose(...fns)`.

The prototype chain; __proto__ vs prototype

How does property lookup actually resolve?

Constructor functions and new — implement myNew

Write a function that replicates what `new` does, step by step.

ES6 classes, extends, super, static, private #fields

Are classes just syntactic sugar? What is genuinely new?

Prototypal vs classical inheritance

Object.create, getPrototypeOf, setPrototypeOf

Property descriptors and Object.defineProperty

What do writable, enumerable and configurable control?

Object.freeze, seal, preventExtensions; deep freeze

Write `deepFreeze(obj)`.

Getters, setters and computed properties

Object statics: keys, values, entries, assign, fromEntries, groupBy

Mixins and composition over inheritance

Proxy and Reflect

How would you build an observable object with a Proxy?

Every array method and its return value

map vs forEach vs filter vs reduce — when does each one belong?

Implement your own map, filter, reduce, forEach

Write `Array.prototype.myReduce` handling the no-initial-value case.

reduce in anger: groupBy, flatten, frequency map, pipe

Group an array of objects by a key using only reduce.

sort — default lexicographic behaviour, comparators, stability

Why does `[10,9,1].sort()` give 1,10,9?

Map and Set — and why not just use an object

When is a Map strictly better than a plain object?

WeakMap and WeakSet

Why would you cache with a WeakMap instead of a Map?

flat, flatMap; implement your own flatten with depth

Array-likes vs iterables; arguments; Array.from

Iterators and the iterable protocol

Make a plain object iterable with `for...of`.

Generators and yield; infinite sequences; async generators

Typed arrays and ArrayBuffer

Sync vs async, blocking vs non-blocking

Callbacks, callback hell, error-first convention

Promises — states, then/catch/finally, chaining rules

What does returning a value vs a promise inside `.then` do?

Promise.all vs allSettled vs race vs any

You fire five API calls and one may fail. Which do you use and why?

async/await, try/catch, for await...of

Sequential vs parallel awaits — the classic perf bug

Spot why awaiting inside a loop made an endpoint 10x slower.

The event loop: call stack, task queue, microtask queue

Predict the output order of setTimeout, Promise.then and sync logs.

Microtasks vs macrotasks

Why does a Promise callback beat a setTimeout(0)?

Debounce and throttle — implement both

Write debounce with leading and trailing edge options. Where would you use each?

Implement your own Promise (then, catch, resolve, reject)

A senior-round favourite. Build it from scratch.

Implement Promise.all and Promise.allSettled polyfills

Retry with exponential backoff

Write `retry(fn, attempts, baseDelay)` with jitter.

Concurrency control — limit N parallel promises

Implement a promise pool that runs at most 3 requests at a time.

promisify; converting a callback API to promises

AbortController — cancelling fetch, timeouts, cleanup

setTimeout(fn,0), setInterval drift, requestAnimationFrame, requestIdleCallback

Race conditions in async UI code

Two searches fire, the slow one lands last. How do you fix it?

Async iterators and streaming responses

CommonJS vs ES modules

Differences in loading, hoisting, live bindings and circular dependencies.

Dynamic import and top-level await

npm vs yarn vs pnpm; lockfiles; npm ci vs npm install

Why does a lockfile matter, and what breaks without one?

Semver, caret vs tilde ranges, peer and dev dependencies

Bundlers: Webpack vs Vite vs esbuild vs Rollup

Why is Vite fast in dev, and what changes in a production build?

Tree shaking, side effects, package.json exports and module fields

Babel, transpiling vs polyfilling, core-js, browserslist

Source maps — how and why

Monorepos: workspaces, Turborepo, Nx

Publishing a package; dual CJS/ESM builds

Garbage collection and mark-and-sweep

Memory leaks in JS: closures, listeners, timers, detached DOM

How would you find a leak in a long-running SPA?

Deep clone — handle nested objects, arrays, Date, Map, Set, cycles

Write it without structuredClone, then mention structuredClone.

Deep equal — implement it

Event bubbling, capturing, delegation

stopPropagation vs preventDefault vs stopImmediatePropagation.

Output-prediction puzzles combining hoisting, closures and the event loop

Do 20 of these. They open a huge share of screening rounds.

Regex: groups, lookahead, greedy vs lazy, flags

Validate an email, extract all matches with groups.

Dates, timezones, and why teams reach for date-fns or dayjs

Why is storing timestamptz in UTC the safe default?

Intl for numbers, currency, dates and relative time

The Temporal API

Why TypeScript; structural vs nominal typing

any vs unknown vs never vs void

When must you use unknown instead of any?

Interfaces vs type aliases

Which do you reach for, and when does the difference actually matter?

Union and intersection types, literal types, discriminated unions

Model an API response that is either success or error, exhaustively.

Generics — functions, interfaces, classes, constraints, defaults

Write a generic `pick<T, K extends keyof T>`.

Utility types: Partial, Required, Pick, Omit, Record, Exclude, Extract, ReturnType, Awaited

Type narrowing, type guards and `is` predicates

Exhaustiveness checking with never

How do you make the compiler fail when a new union member is added?

Typing React: props, children, events, hooks, generic components

Typing Express: req, res, middleware, custom request properties

How do you add `req.user` in a type-safe way?

keyof, typeof, indexed access types, as const

Enums vs const objects vs union of literals

Why do many teams avoid TS enums?

tsconfig essentials: strict, strictNullChecks, target, module, paths

Conditional types and infer

Mapped types and template literal types

Build a type that turns every key into an onXChange handler.

Declaration merging, module augmentation, .d.ts files

Virtual DOM, reconciliation, the diffing heuristics

Is the virtual DOM faster than direct DOM manipulation? Answer honestly.

Keys in lists — why index-as-key is a real bug

Demonstrate a bug caused by index keys with a reorderable list of inputs.

JSX — what it compiles to; fragments

Props, children, composition, render props

How do you avoid prop drilling without reaching for Redux?

useState: batching, functional updates, state as a snapshot

Why does calling setCount(c+1) twice only increment once?

Controlled vs uncontrolled components

Forms: validation, React Hook Form or Formik, error UX

Conditional rendering patterns and their pitfalls

Why does `count && <div/>` render a literal 0?

Lifting state up

Synthetic events; event delegation in React

StrictMode double-invocation in development

Why does your effect run twice in dev, and what is it warning you about?

The rules of hooks — and the reason behind them

Why can't hooks be called conditionally? What breaks?

useEffect: dependency array, cleanup, run timing

useEffect pitfalls: infinite loops, stale closures, missing deps

Your effect reads stale state. Diagnose and fix it.

Race conditions in data-fetching effects

Two fetches, the stale one resolves last. Fix it with a cleanup flag and with AbortController.

You might not need an effect — derived state vs effects

When is deriving during render strictly better than syncing in an effect?

useRef: DOM refs, mutable values, previous-value pattern

useMemo and useCallback — when they help and when they cost

Why does wrapping everything in useCallback make things slower?

React.memo and referential equality

Show a case where React.memo does absolutely nothing.

useReducer — when it beats useState

useContext — and why context re-renders everything below it

How do you stop a context update from re-rendering unrelated consumers?

Custom hooks: useFetch, useDebounce, useLocalStorage, useOnClickOutside, usePrevious

Write three of these from memory.

useLayoutEffect vs useEffect

When does the difference actually show up on screen?

useId, useTransition, useDeferredValue

useImperativeHandle and forwardRef

useSyncExternalStore

How would you subscribe a component to an external store safely?

Class lifecycle equivalents

componentDidMount, DidUpdate, WillUnmount, shouldComponentUpdate, getDerivedStateFromProps.

Why did this component re-render? A systematic answer

Walk through every reason React re-renders a component.

Finding wasted renders: Profiler, React DevTools, why-did-you-render

Code splitting: React.lazy, Suspense, route-based splitting

List virtualisation with react-window or virtuoso

At what list size does virtualisation start to matter?

Error boundaries

Why don't error boundaries catch errors in event handlers or async code?

Fiber architecture: render phase vs commit phase

Concurrent rendering and automatic batching in React 18

What changed about batching between React 17 and 18?

Portals — modals, tooltips, and the z-index escape hatch

Suspense for data fetching

React Server Components vs Client Components

What can and cannot run in an RSC, and why?

Reconciliation edge cases: same position different type, remounting

Server state vs client state vs UI state

The single most useful distinction in modern frontend. Explain it.

Context + useReducer as a Redux alternative

Where does this pattern break down?

Redux core: store, actions, reducers, immutability, middleware

Redux Toolkit: createSlice, createAsyncThunk, RTK Query

TanStack Query: caching, staleTime vs gcTime, invalidation, optimistic updates

What problem does React Query solve that Redux never did?

When would you NOT use Redux?

Redux Thunk vs Saga

Zustand, Jotai, Recoil — and a defensible opinion

Optimistic updates and rollback

Normalising state shape; entity adapters

React Router: routes, nested routes, params, useNavigate, protected routes

CSR vs SSR vs SSG vs ISR

Given a marketing site, a dashboard and a blog — pick a rendering strategy for each and justify it.

Next.js: app router vs pages router, server components, server actions

Hydration and hydration mismatch errors

What causes 'text content did not match' and how do you fix it?

Next.js API routes, middleware, image optimisation

Data loading patterns: loaders, actions, streaming

Micro-frontends and Module Federation — the honest tradeoffs

Box model and box-sizing

Position: static, relative, absolute, fixed, sticky

Why did your sticky header stop sticking?

Flexbox: every property, flex shorthand, common layouts

What does `flex: 1` expand to?

CSS Grid: template areas, auto-fit vs auto-fill, minmax

Build a responsive card grid with no media queries.

Specificity, cascade, inheritance, and !important

Calculate specificity for three competing selectors.

Units: px, rem, em, %, vh, vw, ch, clamp

Why rem over px for typography?

Media queries and mobile-first ordering

Centring a div — every method and when each applies

Stacking context and z-index bugs

Why doesn't z-index: 9999 work here?

Pseudo-classes and pseudo-elements

Transitions, transforms, keyframes; what triggers reflow vs repaint vs composite

Which CSS properties are cheap to animate, and why?

CSS custom properties and theming, including dark mode

Tailwind vs CSS Modules vs styled-components — tradeoffs

Responsive images: srcset, sizes, picture, aspect-ratio

Container queries, :has(), cascade layers, logical properties

What happens when you type a URL and press enter

The classic. Go from DNS all the way to first paint.

Critical rendering path: DOM, CSSOM, render tree, layout, paint, composite

script defer vs async vs neither

Reflow vs repaint; layout thrashing

Spot the thrash in a loop that reads offsetHeight and writes styles.

Cookies vs localStorage vs sessionStorage vs IndexedDB

Compare on size, expiry, sync/async and whether they hit the server.

Cookie attributes: HttpOnly, Secure, SameSite, domain, path

Where do you store a JWT, and defend the choice.

CORS: preflight, the Allow headers, credentials

A request works in Postman but fails in the browser. Explain, then fix it properly.

HTTP caching: Cache-Control, ETag, Last-Modified, max-age, no-cache vs no-store

Core Web Vitals: LCP, INP, CLS, TTFB, FCP

Name a concrete fix for each one.

Debugging with DevTools: network, performance, memory, coverage

Fetch API, headers, FormData, streaming, file uploads

Web Workers — moving CPU work off the main thread

Service workers, PWA, offline caching strategies

WebSockets vs SSE vs long polling

Which would you pick for a live dashboard, and for a chat app?

Bundle analysis and performance budgets

Intersection, Resize and Mutation Observers

Web Vitals measurement in production, RUM vs lab data

Semantic HTML and why div soup fails

Keyboard navigation, focus management, focus trapping in modals

ARIA roles, labels, live regions — and the first rule of ARIA

Colour contrast, alt text, form labelling

XSS: stored, reflected, DOM-based

How does React protect you, and where does it stop? dangerouslySetInnerHTML.

CSRF — what it is and how SameSite plus tokens stop it

Content Security Policy

Clickjacking and X-Frame-Options

SEO: meta tags, Open Graph, sitemaps, robots.txt, structured data

Screen reader testing basics

Internationalisation: locale formatting, RTL, pluralisation

What Node actually is: V8 plus libuv

Is Node single-threaded? Answer precisely — it is a trick question.

The Node event loop phases

timers, pending callbacks, poll, check, close. Where does I/O actually resume?

process.nextTick vs setImmediate vs Promise microtasks

Predict the output order of all three.

Blocking the event loop

A JSON.parse of a 50MB payload stalls every request. Explain why and fix it.

worker_threads vs child_process vs cluster

Which do you reach for to hash passwords for 10k users, and why?

Streams: readable, writable, duplex, transform; piping

Copy a 5GB file without exhausting memory.

Backpressure — what it is and what ignoring it does

Buffers and binary data

EventEmitter — and implement your own

Error handling: operational vs programmer errors, uncaughtException, unhandledRejection

Should you keep the process alive after an uncaught exception? Justify it.

Graceful shutdown on SIGTERM with in-flight requests

Write the shutdown handler.

fs sync vs async vs promises; reading large files

CommonJS module resolution, the require cache, circular requires

process: argv, env, exit codes, signals

util.promisify, path, os, crypto

Memory limits, --max-old-space-size, heap snapshots

Profiling with --inspect, clinic.js, flame graphs

How do you find which endpoint is burning CPU in production?

Native addons and N-API

Node internals: libuv thread pool sizing (UV_THREADPOOL_SIZE)

The request lifecycle; how middleware chaining works

Implement a mini Express with app.use and next().

Middleware types and ordering

Why does your auth middleware not run for this route?

next() vs next(err); the async error trap

Why does a rejected promise in an async handler hang the request in Express 4?

Routing, route params, query strings, Router modules

HTTP status codes that carry meaning

200 vs 201 vs 204, 400 vs 401 vs 403 vs 404 vs 409 vs 422 vs 429.

REST principles, resource naming, idempotency

Which HTTP methods are idempotent? Why does it matter for retries?

Validation at the boundary with Zod or Joi

Centralised error handling and custom error classes

Design the error response shape for a public API.

Pagination: offset vs cursor/keyset

Why does OFFSET 100000 get slow, and what replaces it?

Filtering, sorting, field selection

API versioning strategies

Rate limiting in Express, and doing it correctly behind a load balancer

Structured logging with pino or winston; correlation IDs

How do you trace one user request across three services?

Health checks: liveness vs readiness

Caching layer: cache-aside with Redis, TTLs, invalidation

Background jobs with BullMQ: retries, backoff, dead-letter, idempotency

Your email job ran twice. How do you make it safe?

File uploads: multer, streaming to S3, presigned URLs

Why is a presigned URL better than proxying the upload through your server?

Compression, helmet, CORS configuration

Request timeouts and circuit breakers

Webhooks: signature verification, replay protection, retries

OpenAPI/Swagger documentation

Clustering vs container replicas; PM2

Long-running requests, SSE and WebSockets in Express

GraphQL: schema, resolvers, N+1 and DataLoader

When is GraphQL the wrong choice?

tRPC and end-to-end type safety

NestJS: modules, providers, dependency injection, decorators

Increasingly asked at product companies.

Fastify vs Express — why teams migrate

Authentication vs authorisation

Sessions plus cookies vs JWT

Give a scenario where sessions beat JWT, and one where the reverse is true.

JWT anatomy: header, payload, signature; HS256 vs RS256

Can you decode a JWT without the secret? What does that imply about payload contents?

Access tokens, refresh tokens, rotation, revocation

How do you log a user out of a stateless JWT system?

Where to store tokens: httpOnly cookie vs localStorage

Argue both sides, then pick one.

Password hashing: bcrypt or argon2, salting, work factor

Why is SHA-256 the wrong tool for passwords?

RBAC vs ABAC; permission middleware design

SQL injection and NoSQL injection

Show a vulnerable query and its parameterised fix.

OWASP Top 10 — name them and explain each

IDOR — the most common real-world API bug

Your endpoint is /orders/:id. What is missing?

Secrets management; never committing keys; env var hygiene

OAuth 2.0 authorisation code flow with PKCE; OpenID Connect

Walk through Google sign-in end to end.

HTTPS and the TLS handshake; certificates and the CA chain

SSRF, mass assignment, prototype pollution

Multi-tenancy and data isolation

Audit logging and PII handling

mTLS, service-to-service auth, short-lived credentials

Encryption at rest vs in transit; key rotation

Relational model; primary, foreign, composite, surrogate vs natural keys

Postgres data types: text vs varchar, numeric vs float, timestamptz vs timestamp, uuid, jsonb, arrays, enums

Why timestamptz over timestamp, always?

Constraints: NOT NULL, UNIQUE, CHECK, FK with ON DELETE CASCADE or SET NULL

SELECT: WHERE, ORDER BY, LIMIT, OFFSET, DISTINCT

Joins: INNER, LEFT, RIGHT, FULL, CROSS, SELF

Draw each one. How many rows does a LEFT JOIN return?

Aggregations: COUNT, SUM, AVG, MIN, MAX, GROUP BY, HAVING

What is the difference between WHERE and HAVING?

NULL semantics and three-valued logic

Why does `WHERE col != 'x'` skip NULL rows? COALESCE and NULLIF.

Subqueries, correlated subqueries; EXISTS vs IN vs JOIN

Which performs best on a large table, and why?

CTEs with WITH; recursive CTEs

Query an org chart or a category tree recursively.

Window functions: ROW_NUMBER, RANK, DENSE_RANK, LAG, LEAD, SUM OVER, PARTITION BY

Extremely commonly asked. Know the RANK vs DENSE_RANK vs ROW_NUMBER difference cold.

UNION vs UNION ALL; INTERSECT; EXCEPT

Upsert with ON CONFLICT; RETURNING

CASE expressions and conditional aggregation

Pivot rows into columns without a pivot function.

Views and materialised views

When is a materialised view the right answer?

Generated columns, identity columns, sequences

How a B-tree index works

Why does an index make writes slower?

Index types: B-tree, hash, GIN, GiST, BRIN

Which index type for a jsonb containment query? For full-text?

Composite indexes and column order

Does an index on (a,b) help a query filtering only on b?

Covering indexes, partial indexes, unique indexes

When an index is NOT used

Functions on indexed columns, leading wildcards, low selectivity, type mismatches.

EXPLAIN ANALYZE — reading a query plan

Seq scan vs index scan vs bitmap heap scan; nested loop vs hash join vs merge join.

The N+1 query problem

Show it in an ORM and fix it three ways.

Query optimisation checklist

SELECT *, OR vs UNION, keyset pagination, avoiding sorts, index-only scans.

Table statistics, ANALYZE, and why the planner picks badly

Slow query logging and pg_stat_statements

How do you find your worst query in production?

ACID — explain each letter with a real example

Isolation levels: read committed, repeatable read, serializable

Read phenomena: dirty read, non-repeatable read, phantom read

Map each phenomenon to the isolation level that prevents it.

SELECT FOR UPDATE and row-level locking

Two users book the last seat simultaneously. Prevent the double booking.

Deadlocks: how they happen, how to avoid them

Optimistic vs pessimistic concurrency; version columns

MVCC in Postgres; VACUUM, table bloat, autovacuum

Savepoints and nested transactions

Transactions across HTTP requests — and why you should not

Transaction ID wraparound

Advisory locks

Normalisation: 1NF, 2NF, 3NF, BCNF; update/insert/delete anomalies

Denormalisation — when it is the right call

Modelling relationships: one-to-many, many-to-many, join tables, polymorphic associations

Soft deletes, audit columns, created_at/updated_at

Connection pooling: pg Pool, PgBouncer, pool sizing

Why does raising the pool size sometimes make things slower?

Migrations: Prisma Migrate, Knex, TypeORM

Zero-downtime migrations — the expand and contract pattern

How do you rename a column with no downtime?

Replication: streaming, read replicas, replication lag

A user writes then immediately reads and sees stale data. Explain and fix.

Partitioning and sharding in Postgres

ORMs: Prisma vs TypeORM vs Sequelize vs Knex; when to drop to raw SQL

jsonb: querying, operators, indexing

Full-text search with tsvector vs reaching for Elasticsearch

Backups, PITR, restore drills

Triggers and stored procedures — and why many teams avoid them

Row-level security

Extensions: PostGIS, pg_trgm, pgcrypto, TimescaleDB

Second and Nth highest salary

Three ways: subquery, DENSE_RANK, LIMIT/OFFSET.

Top N per group

Highest-paid employee per department.

Find and delete duplicate rows

Running totals and cumulative sums

Month-over-month and year-over-year growth

Consecutive days or streaks

Users who logged in three days in a row.

Employees earning more than their manager (self-join)

Rows in table A with no match in table B

Three ways: LEFT JOIN IS NULL, NOT EXISTS, EXCEPT.

Gaps and islands

Median and percentiles

Pivoting rows to columns

Cohort retention query

Document model, BSON, collections

When NoSQL beats SQL — and the honest counterargument

You have this app. Postgres or Mongo? Defend the choice.

CRUD and query operators

$gt, $in, $nin, $regex, $exists, $elemMatch, $all.

Update operators

$set, $unset, $inc, $push, $pull, $addToSet, $pop, upsert.

The aggregation pipeline

$match, $group, $project, $sort, $limit, $unwind, $lookup, $facet, $addFields.

Why $match must come first

Explain the performance implication of pipeline stage order.

$lookup — the joins Mongo said it did not need

What are its limits versus a SQL join?

Indexes: single, compound, multikey, text, TTL, partial, unique

The ESR rule for compound index order

Equality, Sort, Range. Explain why.

explain() and reading a Mongo plan

COLLSCAN vs IXSCAN.

Schema design: embed vs reference

One-to-few, one-to-many, one-to-squillions. Give the rule of thumb.

The 16MB document limit and unbounded array growth

Mongoose: schemas, validation, middleware hooks, populate, lean, virtuals

Why is populate secretly an N+1?

Transactions in MongoDB and the replica set requirement

Replica sets, elections, write concern, read preference, read concern

What does `w: majority` guarantee?

Sharding: shard key selection, chunks, hot-spotting

Why is a monotonically increasing shard key a bad idea?

Design patterns: extended reference, bucket, computed, subset, outlier

Change streams

Capped collections and GridFS

Atlas Search and vector search

Redis data types and a use case for each

string, hash, list, set, sorted set, bitmap, stream.

Cache-aside, read-through, write-through, write-behind

Which do you use, and what is the failure mode of each?

TTL, expiry, and eviction policies (LRU, LFU, volatile-*)

What happens when Redis fills up?

Cache invalidation strategies

The hardest problem in computer science. What are your options?

Cache stampede and the thundering herd

A hot key expires and 5000 requests hit the DB at once. Prevent it.

Redis as a rate limiter

Implement a sliding-window counter with INCR and EXPIRE.

Redis as a session store

Distributed locks and the Redlock debate

Persistence: RDB vs AOF

Pub/Sub vs Streams

Sorted sets for leaderboards and delayed queues

Redis Cluster, Sentinel, hash slots

Pipelining and Lua scripts for atomicity

The interview framework: requirements, estimates, API, data model, high level, deep dive, bottlenecks

Rehearse this structure until it is automatic. Never start by drawing boxes.

Functional vs non-functional requirements

Which three questions do you always ask in the first five minutes?

Back-of-envelope estimation: QPS, storage, bandwidth, memory

100M users, 10 posts a day. Size the system.

Latency numbers every engineer should know

Memory vs SSD vs network vs cross-region round trip.

Vertical vs horizontal scaling

Load balancers: L4 vs L7, round robin, least connections, health checks, sticky sessions

Stateless services and why state is the enemy of scaling

Caching at every layer: browser, CDN, reverse proxy, application, database

CDNs — how they work, cache invalidation, edge compute

Database scaling: read replicas, sharding, federation, denormalisation

Sharding strategies: range, hash, directory; resharding pain

Consistent hashing

Draw the ring. Why does it beat modulo hashing when a node dies?

CAP theorem — and why it is more subtle than pick two

Consistency models: strong, eventual, read-your-writes, monotonic, causal

Message queues: Kafka vs RabbitMQ vs SQS

When Kafka, when RabbitMQ? Name the deciding factor.

Delivery semantics: at-most-once, at-least-once, exactly-once

Why is exactly-once mostly a lie, and what do you do instead?

Idempotency keys and idempotent consumers

Dead letter queues, retries with jitter, poison messages

Synchronous vs asynchronous communication

Which parts of a checkout flow must be sync, and which must not?

Rate limiting algorithms

Fixed window, sliding log, sliding counter, token bucket, leaky bucket. Implement one.

Unique ID generation at scale

UUID v4 vs v7 vs ULID vs Snowflake. Why is a UUID v4 primary key bad for a B-tree?

Monolith vs microservices vs modular monolith

You have a 6-person team. Which, and why?

API gateway, BFF pattern, service discovery

Circuit breaker, bulkhead, timeouts, graceful degradation

Observability: metrics, logs, traces; SLI, SLO, SLA, error budgets

Saga pattern, two-phase commit, the transactional outbox

How do you keep a DB write and a Kafka publish consistent?

Event sourcing and CQRS

Search: inverted index, Elasticsearch basics, relevance

Blob storage, S3, presigned URLs, multipart upload

WebSockets at scale: connection state, sticky routing, pub/sub fanout

Availability maths, redundancy, failover, RPO and RTO

Load testing with k6 or Artillery

Bloom filters and count-min sketch

Leader election, Raft, ZooKeeper/etcd

Geo-distribution, multi-region active-active, data residency

Vector clocks and conflict resolution (CRDTs)

Design a URL shortener

The warm-up. Key generation, collisions, redirects, analytics, cache.

Design a rate limiter as a service

Design a news feed (Twitter/Instagram)

Fanout on write vs fanout on read. Handle the celebrity problem.

Design a chat application (WhatsApp)

WebSockets, presence, delivery receipts, ordering, offline messages.

Design a notification system

Push, email, SMS; fanout, deduplication, user preferences, retries.

Design an e-commerce checkout with inventory

Prevent overselling. Reservations, timeouts, idempotent payment.

Design a ticket-booking system (BookMyShow)

Seat locking under concurrency is the whole question.

Design a food delivery or ride-hailing system

Geospatial indexing, matching, order state machine, live tracking.

Design a file storage and sync service (Dropbox)

Chunking, deduplication, conflict resolution, sync protocol.

Design a video platform (YouTube/Netflix)

Upload, transcoding pipeline, adaptive bitrate, CDN.

Design typeahead/autocomplete

Trie, ranking, caching, debounce on the client.

Design a payment system

Idempotency, ledger, double-entry bookkeeping, reconciliation, webhooks.

Design a web crawler

Design a distributed job scheduler or cron service

Design a logging and monitoring pipeline

Design a multi-tenant SaaS application

Data isolation strategies and their tradeoffs.

Design a feature-flag service

Design Google Docs (collaborative editing)

OT vs CRDT — awareness is enough.

Design an analytics/event ingestion pipeline

Design a distributed cache

Component architecture and a design system

How do you structure a large React codebase so it stays navigable?

Client-side data layer: caching, invalidation, optimistic updates

Design an autocomplete component

Debounce, cancellation, caching, keyboard nav, accessibility, race conditions.

Design an infinite-scrolling virtualised feed

Frontend performance strategy

Bundle budget, code splitting plan, image strategy, font loading, prefetching.

Design an image gallery with lazy loading

Design an offline-first app with background sync

Design a real-time dashboard

Polling vs SSE vs WebSocket, and how you decide.

Error handling, retry and loading-state architecture

Analytics and event tracking architecture

Micro-frontends: when the org problem justifies the technical cost

Design a rich text editor

SOLID — all five, each with a real example from your own code

Give a concrete violation you have personally fixed.

DRY, KISS, YAGNI, composition over inheritance, law of Demeter

Layering: controller, service, repository

Why should a controller never touch the database?

Dependency injection and inversion of control

Creational patterns: Singleton, Factory, Abstract Factory, Builder

Structural patterns: Adapter, Decorator, Facade, Proxy

Behavioural patterns: Observer, Strategy, Command, State, Chain of Responsibility, Template Method

Which pattern replaces a growing if/else chain?

Repository pattern and why it makes testing possible

Clean and hexagonal architecture; ports and adapters

Domain modelling: entities, value objects, aggregates

Code smells and refactoring moves

Anti-patterns: God object, anaemic domain model, service locator

In-memory key-value store with TTL

LRU cache from scratch (map plus doubly linked list)

Rate limiter (token bucket) as a reusable class

Parking lot system

Splitwise / expense sharing

Design a URL shortener as working code, not a diagram

Task or job scheduler with retries

Elevator system

Vending machine or ATM (state pattern)

BookMyShow seat booking

Tic-tac-toe, snake and ladder, or chess

Logging framework with pluggable appenders

Notification service with multiple channels

Library management system

Practise the format itself

90 minutes, working code, clean folder structure, a few tests, a README explaining tradeoffs. Do three timed runs.

Big-O, big-Theta, big-Omega; time and space complexity

Analyse a nested loop, a recursive call, and a function with a hash map.

Amortised analysis

Why is push to a dynamic array O(1) amortised?

Recursion: base cases, call stack, recursion trees

Complexity of JavaScript operations

shift, unshift, splice, spread, object key lookup, Map vs object.

Space complexity of recursion vs iteration

Two pointers

Two sum sorted, three sum, container with most water, remove duplicates, sort colours.

Sliding window, fixed and variable size

Longest substring without repeating characters, minimum window substring, max sum subarray of size k.

Prefix sums and difference arrays

Subarray sum equals k, range sum queries.

Hash maps and sets

Two sum, group anagrams, longest consecutive sequence, frequency counting.

Kadane's algorithm

Maximum subarray, maximum product subarray.

String manipulation

Palindromes, anagrams, string compression, reverse words, roman numerals.

Matrix problems

Spiral traversal, rotate image, set matrix zeroes, search a 2D matrix.

Cyclic sort and finding missing/duplicate numbers

Dutch national flag partitioning

Linked list basics: traverse, insert, delete, reverse (iterative and recursive)

Fast and slow pointers

Cycle detection (Floyd), find the middle, find cycle start.

Merge two sorted lists; merge k sorted lists

Reverse in groups of k; palindrome linked list; reorder list

Stacks: valid parentheses, min stack, evaluate RPN

Monotonic stack

Next greater element, daily temperatures, largest rectangle in histogram, trapping rain water.

Queues and deques

Sliding window maximum, implement a queue using stacks.

LRU cache — the single most-asked design-flavoured problem

LFU cache

Doubly linked lists and their use in caches

Traversals: preorder, inorder, postorder (recursive and iterative), level order

DFS vs BFS on trees — and when each is right

Height, diameter, balanced check, same tree, symmetric tree, invert tree

BST: search, insert, delete, validate, kth smallest, inorder successor

Why does an inorder traversal of a BST give sorted output?

Lowest common ancestor, in a BST and in a general binary tree

Path problems: root-to-leaf sum, max path sum, all paths

Serialise and deserialise a binary tree

Tree views: left, right, top, bottom; vertical order traversal

Tries: implement insert, search, startsWith

Word search II, autocomplete, longest common prefix.

Construct a tree from preorder and inorder traversals

Binary tree to doubly linked list; flatten to linked list

Segment trees and Fenwick trees

Heaps and priority queues — implement a min heap

Top K problems

K largest elements, top K frequent, K closest points.

K-way merge; median from a data stream (two heaps)

Task scheduler; reorganise string

Interval problems

Merge intervals, insert interval, non-overlapping intervals, meeting rooms I and II.

Greedy: jump game, gas station, activity selection, partition labels

When is greedy provably correct?

Sweep line technique

Representations: adjacency list vs matrix; building a graph from edges

BFS and DFS on graphs; connected components

Grid as a graph

Number of islands, rotting oranges, flood fill, shortest path in a binary maze, word ladder.

Cycle detection, directed and undirected

Topological sort (Kahn's and DFS)

Course schedule I and II, alien dictionary.

Dijkstra's shortest path

Network delay time, cheapest flights within k stops.

Union-Find with path compression and union by rank

Number of provinces, redundant connection, accounts merge.

Bellman-Ford and Floyd-Warshall

Minimum spanning tree: Kruskal and Prim

Bipartite check and graph colouring

Tarjan's algorithm, bridges and articulation points

Binary search on a sorted array; first and last occurrence

Get the boundary conditions right without guessing.

Binary search on the answer

Koko eating bananas, split array largest sum, capacity to ship packages, minimum in rotated array.

Search in a rotated sorted array; find peak element

Median of two sorted arrays

Sorting algorithms: bubble, selection, insertion, merge, quick, heap, counting, radix

Complexity, stability, and when each is actually used.

Quickselect for the kth largest

Bit manipulation basics

XOR tricks, single number, count set bits, power of two, swap without temp.

Subsets via bitmask

What algorithm does JavaScript's Array.sort use?

Backtracking template

Subsets, permutations, combinations, combination sum.

N-Queens, sudoku solver, word search, palindrome partitioning, rat in a maze

Memoisation vs tabulation; how to spot a DP problem

What are the two signals that a problem is DP?

1D DP

Climbing stairs, house robber I and II, decode ways, jump game.

Knapsack family

0/1 knapsack, unbounded knapsack, subset sum, equal partition, target sum, coin change.

String DP

Longest common subsequence, edit distance, longest palindromic substring, distinct subsequences.

Longest increasing subsequence (n^2 and n log n)

Grid DP

Unique paths, minimum path sum, with obstacles.

Stock buy and sell — the whole series

One transaction, unlimited, with cooldown, with fee, at most k.

Matrix chain multiplication and partition DP

DP with bitmask; digit DP

Work Blind 75 first, then NeetCode 150

Timebox to 25 minutes, then read the solution and re-solve from scratch two days later

Say the approach and complexity out loud before writing a line of code

This is what the interviewer is actually grading.

Always state edge cases: empty input, single element, duplicates, negatives, overflow

Dry run your code on an example before saying you are done

Keep a mistakes log and revisit it weekly

Do company-tagged problem sets once you have real interviews scheduled

Process vs thread; context switching

Concurrency vs parallelism

Explain the difference using Node as the example.

Deadlock: the four necessary conditions, prevention, avoidance, detection

Race conditions, mutex vs semaphore, critical sections

Virtual memory, paging, page faults, thrashing

CPU scheduling algorithms: FCFS, SJF, round robin, priority

Producer-consumer and reader-writer problems

IPC mechanisms: pipes, shared memory, message queues, sockets

How Node's single-threaded model maps onto all of this

File systems, inodes, journaling

What happens when you type a URL and press enter

Rehearse a 3-minute version and a 30-second version.

OSI model vs TCP/IP model

TCP vs UDP; the three-way handshake and four-way teardown

Why does a video call use UDP and a file download use TCP?

DNS resolution end to end; A, AAAA, CNAME, MX, TXT records; TTL and caching

HTTP methods, idempotency, safety, status codes

HTTP/1.1 vs HTTP/2 vs HTTP/3

Head-of-line blocking, multiplexing, header compression, QUIC.

HTTPS and the TLS handshake; symmetric vs asymmetric encryption; certificates

REST vs GraphQL vs gRPC vs WebSocket

Flow control vs congestion control

Proxies, reverse proxies, NAT, firewalls

Ports, sockets, keep-alive, connection reuse

Where latency actually comes from

DNS, TCP, TLS, TTFB; bandwidth vs latency.

Subnetting and CIDR basics

ER modelling, cardinality, relationship types

Functional dependencies and normalisation, with anomalies

B-tree vs B+ tree and why databases use B+ trees

ACID vs BASE

Concurrency control protocols: 2PL, timestamp ordering

Clustered vs non-clustered indexes

Write-ahead logging and recovery

The three areas: working directory, staging, repository

Merge vs rebase

When would you rebase, and when is it dangerous?

Resolving conflicts confidently

reset soft vs mixed vs hard; revert vs reset

You pushed a bad commit to main. What now?

cherry-pick, stash, reflog

How do you recover a commit you thought you destroyed?

Branching strategies: Git Flow, GitHub Flow, trunk-based

git bisect to find the commit that broke it

Interactive rebase, squashing, fixup commits

Tags, semantic versioning, release process

Code review etiquette and conventional commits

Submodules, sparse checkout, monorepo vs polyrepo

File permissions, ownership, chmod and chown

Processes: ps, top, htop, kill, signals, nohup

Text processing: grep, awk, sed, cut, sort, uniq, wc

Find the top 10 IPs in an access log with one pipeline.

Networking tools: curl, netstat, lsof, dig, telnet

A port is in use. Find what is holding it.

ssh, scp, key-based auth

systemd services, journalctl, cron

Disk and memory: df, du, free

Basic shell scripting: variables, conditionals, loops, exit codes

Images vs containers; how layers and caching work

Why does reordering your Dockerfile speed up builds?

Writing a good Dockerfile for a Node app

Multi-stage build, non-root user, .dockerignore, small base image.

Volumes, networks, port mapping, environment variables

docker-compose for local development

Container vs virtual machine

Image size optimisation and layer caching in CI

Container registries and image tagging strategy

Kubernetes basics: pods, deployments, services, ingress

ConfigMaps, secrets, readiness and liveness probes, HPA, rolling updates

Helm, namespaces, resource limits and requests

What a CI pipeline should do: lint, typecheck, test, build, deploy

Describe your ideal pipeline for a Node plus React repo.

GitHub Actions: workflows, jobs, steps, caching, secrets, matrix builds

Deployment strategies: rolling, blue-green, canary

Feature flags and decoupling deploy from release

Environments, configuration, and the twelve-factor app

Why does configuration belong in the environment?

Rollback strategy

Your deploy broke production. Walk through the next ten minutes.

Database migrations in a CI/CD pipeline

Artifact versioning and reproducible builds

Infrastructure as code with Terraform

AWS core services and what each is for

EC2, S3, RDS, Lambda, API Gateway, CloudFront, Route53, IAM, VPC, SQS, SNS, ECS/Fargate, CloudWatch.

IAM: users, roles, policies, least privilege

VPC, subnets, security groups vs NACLs

Why should your database never have a public IP?

Nginx as a reverse proxy: SSL termination, static files, load balancing

Monitoring and alerting: what do you actually alert on?

Why is CPU a bad alert and latency a good one?

Reading production logs to debug a live incident

Serverless: cold starts, execution limits, when Lambda fits

Autoscaling policies and capacity planning

Secrets management: Secrets Manager, Parameter Store, Vault

Incident response and blameless postmortems

Cost awareness: what actually runs up a cloud bill

Distributed tracing with OpenTelemetry

CDN configuration and cache invalidation at the edge

The testing pyramid and the testing trophy

Where do you get the most confidence per minute spent?

Unit vs integration vs end-to-end — and what you would not test

Mocks vs stubs vs spies vs fakes

What makes a test valuable versus a test that just slows you down

Why are snapshot tests so often useless?

Test-driven development — what it is and when you would actually use it

Flaky tests: causes and cures

Coverage as a metric and how it misleads

Contract testing between services

Jest or Vitest: matchers, mocks, spies, fake timers, setup and teardown

Testing async code and promises

React Testing Library: queries, user-event, testing behaviour not implementation

Why does RTL discourage testing state directly?

Mocking network calls with MSW

Testing Express APIs with Supertest

Test database strategy: containers, transactions, fixtures, factories

How do you keep integration tests isolated and fast?

End-to-end with Playwright or Cypress

Testing custom hooks

Load and performance testing

A systematic debugging method

Reproduce, isolate, hypothesise, verify. Talk through a real bug you fixed this way.

Chrome DevTools and the Node inspector; breakpoints, watch, call stack

Debugging production: logs, traces, metrics, source maps

ESLint and Prettier; husky and lint-staged pre-commit hooks

What you look for in a code review

Code smells and the refactorings that fix them

Long function, large class, feature envy, primitive obsession, shotgun surgery.

Cyclomatic complexity and when to split a function

Documentation: README quality, architecture decision records

Technical debt: how you track it and how you argue for paying it down

How React Native works: JS thread, native/UI thread, shadow thread

The old bridge vs the new architecture

JSI, Fabric, TurboModules, Codegen. Why was the bridge replaced?

Hermes — what it changes for startup time and memory

React Native vs Flutter vs native

When would you tell a client NOT to use React Native?

Expo vs bare workflow; EAS build

What forces you to eject, and what no longer does?

Metro bundler and how RN differs from a web build

How native modules work; writing and autolinking one

Core components: View, Text, Image, ScrollView, FlatList, SectionList, TextInput, Pressable, Modal, SafeAreaView

FlatList performance

keyExtractor, getItemLayout, windowSize, initialNumToRender, removeClippedSubviews, memoised renderItem. Your list janks — diagnose it.

ScrollView vs FlatList — and why using the wrong one kills the app

Styling: StyleSheet, flexbox differences from web, Dimensions, PixelRatio

Why is there no CSS, and what is the default flexDirection?

Handling different screen sizes, notches, safe areas

Platform-specific code: Platform.select and .ios/.android files

React Navigation: stack, tab, drawer, nesting, params, auth flow

How do you structure a logged-in vs logged-out navigator?

Deep linking and universal links

Storage: AsyncStorage, MMKV, SQLite, secure storage

Where do you keep an auth token on mobile?

Permissions, camera, geolocation, file access

Push notifications: FCM and APNs, tokens, foreground vs background handling

Offline-first: queueing mutations, sync, conflict resolution

Animations: Animated vs Reanimated; Gesture Handler; running on the UI thread

Why does Reanimated feel smoother than the Animated API?

Images: caching, resizing, FastImage, memory pressure

Forms and keyboard handling on mobile

Debugging: React Native DevTools, Flipper, Hermes profiling

App size optimisation: ProGuard/R8, Hermes bytecode, asset trimming

Release process: signing, keystores, provisioning profiles, TestFlight, Play Console

Walk through releasing v1.1 to both stores.

Over-the-air updates: CodePush or EAS Update, and the store rules that limit them

What can you ship OTA and what legally cannot go OTA?

Crash reporting with Sentry or Crashlytics; reading a native stack trace

Environment configuration and build variants/flavours

CI for mobile: Fastlane, EAS, automated builds

Analytics and funnel tracking in an app

Upgrading React Native versions without losing a week

Tell me about yourself

90 seconds: where you are now, what you have built, why you are looking, what you want next. Write it, then rehearse it until it is not a recitation.

Walk me through your current project

Architecture, your specific contribution, the hardest decision, real numbers.

Why are you leaving your current company?

Honest, forward-looking, never bitter. Prepare the exact wording.

Why this company / why this role?

Requires actual research. Generic answers are visibly generic.

Where do you see yourself in three years?

Your greatest strength and a real weakness

A weakness you are genuinely working on, with evidence.

Why should we hire you over someone from a product company?

Prepare this one verbatim. It will come.

Questions you ask the interviewer

Team structure, on-call, how tech debt is handled, what success looks like at 6 months, why the role is open.

Explain a technical concept to a non-technical stakeholder

A hard bug you debugged

Situation, what you tried, how you isolated it, the fix, what you changed afterwards.

A time you improved performance

With before and after numbers. This is the highest-value story you own.

A conflict with a teammate or manager

A time you missed a deadline or shipped something broken

What you owned, what you changed structurally.

A time you disagreed with a technical decision

Did you commit anyway? How?

A time you took ownership beyond your role

Something complex you learned quickly under pressure

Feedback you received and acted on

A time you mentored or unblocked someone

A tradeoff you made deliberately — and would you make it again

A time you pushed back on scope or requirements

How you handled a production incident

Thinking out loud while coding

Silence reads as being stuck. Practise narrating.

Asking clarifying questions before you start

In every round, always. It is graded.

Handling a question you do not know

Say what you do know, reason toward it, never bluff. Interviewers respect this and punish bluffing.

Recovering after a bad round

Mock interviews: peers, Pramp, or record yourself

Do at least six before your first real interview.

Salary negotiation

Know your number, avoid disclosing first, negotiate total comp, use competing offers. Never accept on the call.

Discussing notice period, offer timelines and juggling processes

Post-interview follow-up

Remote interview logistics: setup, connection, screen sharing, editor ready

One page, reverse chronological, no photo, no skill bars

Impact-first bullets: action, technology, measurable result

Rewrite every bullet that begins with 'Responsible for'.

Quantify everything you honestly can

Latency, users, requests, cost, time saved, bugs reduced, build time.

Only list skills you can survive 20 minutes of questioning on

Anything on your resume is fair game. Cut the rest.

ATS-friendly formatting; keywords pulled from real job descriptions

Frame service-based work as breadth

Multiple clients, domains, end-to-end ownership, shipping under real deadlines.

A short professional summary tuned per role type

Get it reviewed by two people who have hired engineers

Pin three strong GitHub repos with real READMEs

Problem, architecture diagram, decisions, setup, screenshots.

One flagship project that shows depth

Auth, real data modelling, caching, background jobs, tests, CI, deployed and reachable.

LinkedIn: headline, About section, experience mirrored from the resume, open-to-work signals

Clean up commit history and remove dead repos from the top of your profile

Write two short technical posts about something you actually debugged

Cheap credibility, and it gives interviewers something to ask about.

A personal site or portfolio page

Start applying at the end of week 2 — do not wait until you feel ready

Early interviews are diagnostics. They will tell you what is actually weak.

Referrals: how to ask, and a cold outreach template that is not spam

A referral converts several times better than a portal application.

Track every application in one sheet

Company, role, source, date, stage, contact, next action.

Keep 15 to 20 live pipelines so no single outcome matters

Research each company before the first round

Product, stage, tech stack, recent news, who is interviewing you.

Take-home assignments: scope, timebox, README, tests

Do not gold-plate. Do explain your tradeoffs in writing.

Try to bunch onsites so offers land in the same window

That is what creates negotiating leverage.

Know your target number and your walk-away number before any call