Problems
Callback's own problems and the LeetCode questions companies have been asking, in one place — pick a category, then filter by company, frequency, status, difficulty, topic, and language.
Frontend · List state done right: keys, controlled input, and deletes.
StoreData with Change Listeners
Frontend · A Backbone.Model-style store: two Maps, one event-key normalizer, listeners that can't break each other.
Frontend · A one-way state machine, a handler queue, and every callback in a microtask.
Debounce with Cancel and Flush
Frontend · A trailing-edge debounce whose wrapper can also drop the pending call or run it now.
Frontend · Declarative rule factories and one message per field — the first failing rule's.
Frontend · A tab UI packaged as an initializer — two independent instances from one function.
Frontend · Real radio inputs behind the stars: the form submits itself, the keyboard works, N instances are N names.
Frontend · Fisher–Yates, a splice, and fresh nodes per deal — the reveal animation comes free.
Typeahead with Keyboard Navigation
Frontend · Debounce the query, abort the stale request, cache by query, wrap the arrow keys, wire the combobox.
Carousel with a Per-Slide Countdown
Frontend · One interval per slide, one batched update per advance — and the double-advance trap.
Frontend · Immutable board updates, gravity in dropPiece, and a win check that only looks through the last move.
Frontend · Two arrays and one Set of checked ids — get a working version fast, then polish.
Implement Array.prototype.flat
Frontend · Depth, holes and Infinity — without recursion, so 100,000 levels can't overflow the stack.
Frontend · Pre-size the output so holes stay holes, and forward thisArg.
Frontend · Take functions, not promises — then never call the next task until the previous one settles.
Frontend · A sliding window of N workers: results in input order, nothing new after a failure.
Frontend · A promise that settles after a second, rejecting with an Error — then consumed with await and try/catch.
Frontend · Explain the prototype chain, then rebuild a class ... extends pair from constructor functions, without the new Parent() trap.
Frontend · Cycles, shared references, Date, RegExp, Map, Set, prototypes and symbol keys: everything spread and JSON get wrong.
Frontend · A closure over a Map keyed on every argument — and has, not truthiness, so 0 and undefined still hit.
Frontend · Read a nested value by path, and return the fallback only when it is missing, never when it is merely falsy.
Frontend · Step by size and slice — after clamping the size, because 0 loops forever.
Frontend · The dotted path to every primitive in a nested object or array — even when the input has cycles.
Frontend · Turn { id, name, parentId } rows into a tree in one pass, then render every level as tabs under its parent.
Frontend · Pack cards of different heights into tight columns with CSS alone, then explain what CSS-only masonry cannot do.
Frontend · A promise around a <link>, memoized by href, that forgets failures so a retry can work.
Multi-Step Form With a Shared Store
Frontend · Three steps, one reducer: data survives Back, each step validates before Next, and submitting locks the form.
Star Rating With Half Stars, at Scale
Frontend · Click to fill, half stars from the click position, a thousand stars, and updates that touch only what changed.
Tic-Tac-Toe: N by N, M in a Row
Frontend · A board of any size, a win check that looks only through the last move, and a status line for turn, winner or draw.
Frontend · Six one-digit fields that feel like one: advance on entry, Backspace back, paste the whole code, lock while verifying.
Image Carousel With One Image Element
Frontend · Previous, next and page buttons that wrap around, any aspect ratio fitted to a fixed frame, and a single <img>.
Predict the Output: Promise and Timer Order
Frontend · A promise resolved inside a timer, two more timers, and a microtask: the event loop decides the order.
Predict the State: A Redux Reducer
Frontend · Trace three dispatches through a reducer by hand — and read the case labels character by character.
Frontend · A function plus the bindings of the scope it was created in — bindings, not snapshots.
Frontend · Capture down, target, bubble up — and why delegation depends on it.
Frontend · Browsers block cross-origin reads unless the server opts in — it protects users, not servers.
Frontend · Group items by key into a null-prototype object — because {} already has "constructor".
Implement Array.prototype.filter
Frontend · Skip holes, forward thisArg, and keep the elements whose callback is truthy.
Implement Array.prototype.reduce
Frontend · A missing initial value versus an undefined one — and the TypeError when there's nothing to reduce.
Implement Array.prototype.concat
Frontend · Spread arrays and isConcatSpreadable objects one level, keep holes, append everything else.
Drive a Generator Like async/await
Frontend · Resume the generator with each resolved value, and throw each rejection back in at the yield.
Frontend · Start every call at once and let Promise.all keep the input order.
Frontend · Store results by index, count down, resolve an empty input at once, reject on the first failure.
Frontend · Race the promise against a timer — and clear the timer when the promise wins.
Frontend · Collect arguments until fn.length have arrived — with a fresh array per call so partials stay independent.
Frontend · A called flag, not a check on the result — and the first call's this and arguments.
A Tooltip Library From data Attributes
Frontend · One tooltip node, delegated listeners, keyboard focus and Escape — in plain DOM, not a component.
Predict the Output: What a Spread Copies
Frontend · { ...first } copies the top level only — a nested object stays shared.
Predict the Output: `this` in an Arrow Method
Frontend · An arrow function takes this from where it is defined — and an object literal is not a scope.
Predict the Output: The Temporal Dead Zone
Frontend · A block-scoped const shadows the outer one from the top of its block — before its line runs.
Predict the Output: A then and finally Chain
Frontend · A promise settles once, finally passes values through, and a rejection handler can recover.
Predict the Output: var Hoisting With Shadowing
Frontend · A var inside the function is hoisted and initialized to undefined, shadowing the outer one.
Predict the Result: Type Coercion
Frontend · What adding "0" to a number does, and a table of +, == and comparison gotchas.
Predict the Output: async/await and the Microtask Queue
Frontend · An async function runs synchronously up to its first await; the rest is a microtask.
Predict the Output: var and let in a Loop With Timers
Frontend · var gives the loop one shared binding; let gives each iteration its own.
Predict the Output: Nested Context Providers
Frontend · Default value, nearest provider, and why memo doesn't stop a context update.
Which Effect Fetches Data Once on Mount?
Frontend · No dependency array loops, an async effect returns a promise, and a fetch in the render body runs every render.
Which Statement About React Context Is Correct?
Frontend · Context in React 16.3 and later: how it's created and who can read it.
What Are the States of a Promise?
Frontend · Pending, then fulfilled or rejected — settled is final, and handlers always run later.
What Were the Best Improvements in ES6?
Frontend · Pick two features and say which bug each one removed.
Frontend · "Is a" ties the child to the parent; "has a" combines small parts.
Frontend · The byte order of multi-byte values — and where JavaScript makes you care.
What Do Object-Oriented Languages Share?
Frontend · Encapsulation, inheritance and polymorphism — and how JavaScript gets inheritance.
Cookies, localStorage or sessionStorage?
Frontend · Size, lifetime and who can read it — HttpOnly cookies survive XSS.
Frontend · HTTPS, CSP, cookie flags and escaping — each named with the attack it stops.
Frontend · fetch resolves on a 500; Axios rejects, parses JSON and intercepts.
Frontend · One round trip and typed data, paid for in caching, query cost and N+1 resolvers.
How Do You Build an npm Package?
Frontend · package.json fields, ESM builds with types, peer dependencies, and a dry-run before publishing.
What Makes a Good Code Review?
Frontend · Correctness first, then readability and tests — small diffs, specific comments.
How Would You Structure a Repo From Scratch?
Frontend · Group by feature, keep tests beside code, and wire checks into CI from the first commit.
Frontend · Name what you test with it — including timers with fake timers.
When Would You Use useMemo or useCallback?
Frontend · They cache a value and a function identity — and only matter when something compares them.
preventDefault or stopPropagation?
Frontend · One cancels the browser's default action; the other stops the event traveling.
Why <!DOCTYPE html>, and What Is Quirks Mode?
Frontend · The doctype selects standards mode; without it, browsers emulate 1990s layout.
Frontend · A GPU texture the compositor can move or fade without layout or paint.
How Do You Make a Page Accessible?
Frontend · Native elements first, then names, keyboard, contrast, motion — and a real example.
How Would You Implement Light and Dark Themes?
Frontend · Custom properties on the root, prefers-color-scheme by default, and no flash of the wrong theme.
How Do You Adjust a Border or a Margin?
Frontend · Content, padding, border, margin — and what border-box changes about width.
How Does the Browser Turn HTML Into Pixels?
Frontend · DOM, CSSOM, render tree, layout, paint, composite — six numbered steps.
Frontend · Which pipeline steps each kind of change re-runs — and how reads force layout.
Frontend · First Contentful Paint and Largest Contentful Paint, with their good thresholds.
How Would You Debug a Blank Page?
Frontend · Console, network, DOM, then bisect the deploys.
How Would You Make a Site Faster?
Frontend · Measure first, then ship less, unblock rendering, cache, and move work.
How Do You Deal With a Slow API?
Frontend · Show a shell at once, cache and parallelize, cancel stale requests — then fix the server.
A Heavy Calculation Freezes the UI
Frontend · Move it to a Web Worker — or chunk it and yield when a worker isn't an option.
Frontend · Promises can't be cancelled, so cancel the work — and reject once, with an AbortError, only while pending.
Frontend · A leading call, then at most one call per window — with a trailing call that carries the latest arguments.
Frontend · Columns of cards with immutable moves: one pure moveCard function serves the buttons and the drag-and-drop alike.
Frontend · State in one object, a pure toggle that flips a cell and its neighbours, one delegated click listener, and a render from state.
Frontend · A map from event name to listener list; copy the list before emitting so listeners can unsubscribe mid-emit.
Frontend · Primitives by value (NaN equals NaN), arrays by length and elements, plain objects by key set and values, recursively.
Frontend · A recursive serializer with the real rules: undefined vanishes from objects but becomes null in arrays, and strings need escaping.
Frontend · Two stacks: a new value pushes the old one onto undo and clears redo; undo and redo move values between them.
Frontend · Derive the 64 squares in render — no board in state — then add selection and a move with one piece of state.
Frontend · Keyboard movement with walls and edges, then a breadth-first path to the nearest candy walked one cell at a time.
Frontend · Remember the order cells were lit; when all are lit, a self-re-arming timeout switches them off in reverse.
Frontend · A shuffled deck, at most two face-up ids, a set of matched faces, and one effect that resolves each pair.
Frontend · Two intervals owned by one effect keyed on the running flag, and a round that ends when the clock hits zero.
Frontend · Two corners in state and a derived rectangle; pointer events on cells plus one document listener for the release.
Frontend · A flat array of 225 colours, a palette, draw and erase modes, and a stroke that paints while the pointer is held.
Frontend · Store only the leaves; every parent's checked and indeterminate state is derived from the leaves beneath it.
Frontend · Three pieces of state — page, page size, sort — and rows derived from them in render.
Frontend · A recursive component over nested data, with a set of expanded ids as the only state.
Frontend · A state copy of the value and one effect whose cleanup cancels the pending update on every change.