Hard frontend interview questions

Build a fully accessible accordion with keyboard navigation per the ARIA authoring practices guide.

Build an emitter whose emit awaits async listeners, with once, off, and serial or parallel dispatch.

Implement Node-style async runners — run error-first tasks in parallel or in series and collect their results.

Implement a read-write lock that allows many concurrent readers or one exclusive writer without starving writers.

Build a six-cell auth code input that handles typing, paste, backspace, and arrow-key navigation across fields.

Build a production autocomplete with async fetch, debounce, keyboard navigation, caching, and match highlighting.

Implement a Backbone-style Model class that stores attributes and emits change events per key.

Build a binary search tree with insert, search, and delete operations preserving the BST invariant.

Implement a function that returns the maximum sum of node values along any path in a binary tree.

Implement functions that convert a binary tree to a string and reconstruct the same tree back from that string.

Build an accessible week-view scheduler with add/remove controls, live announcements, and spatial keyboard navigation.

Extend the classNames utility to dedupe class names and resolve function arguments lazily.

Run a queue of tasks in time slices, yielding control between them so the main thread stays responsive.

Implement a curry helper that turns a variadic function into one that can be called repeatedly with any number of arguments.

Implement a function that filters an array of row objects by a flexible field-and-condition specification.

Build a generic, reusable data table that supports column-driven sorting and pagination for any dataset.

Build a generalized data table component that supports pagination, column sorting, and per-column filtering.

Build a data table with sortable columns, pagination, and row selection over a dataset.

Batch and cache load(key) calls made in one tick into a single batch function call, preserving order.

Implement a deep clone that copies nested values and correctly handles circular references using a visited map.

Implement a function that determines whether two values are structurally equal across nested objects and arrays.

Implement Dijkstra's algorithm to compute shortest paths from a source vertex in a weighted graph.

Reorder a list by pointer drag, computing the target index from the cursor over item midpoints.

Build an in-memory query builder inspired by Drizzle with table helpers, filters, sorting, and pagination.

Extend an in-memory query builder inspired by Drizzle with select projections and column aliases.

Extend an in-memory query builder inspired by Drizzle with innerJoin and leftJoin between related tables.

Given words sorted in an unknown alphabet's order, reconstruct the alphabet.

Build a Fenwick tree for logarithmic prefix-sum queries and point updates, using the lowest-set-bit trick to walk responsibility ranges.

Implement a function that returns every word from a dictionary that can be traced through adjacent cells in a grid.

Build a Gantt chart that renders tasks as bars positioned across a timeline by start and duration.

Implement a function that finds all DOM elements matching an ancestor-to-descendant tag-name hierarchy.

Implement a binary heap data structure supporting push, pop, peek, and heapify with the standard ordering invariant.

Implement heap sort by building a max-heap and repeatedly extracting the largest element.

Tokenize an HTML string and build a nested node tree, handling attributes, void, and nested tags.

Run a queue of tasks in time-sliced batches, yielding between slices to keep the frame responsive.

Build an image carousel that smoothly transitions between images while keeping the DOM footprint minimal.

Build an image cropper with a draggable, resizable crop region over an image.

Implement produce so mutating a draft proxy yields a new immutable state with structural sharing.

Spell out a non-negative integer in English words — break it into groups of three digits and name each group with its scale word.

Implement JSON.parse — a recursive-descent parser that turns a JSON string into the corresponding JavaScript value.

Implement JSON.stringify with full spec support including replacer, indentation, and circular reference detection.

Reconcile two keyed child lists into a minimal set of DOM inserts, moves, and removals.

Build a collapsible tree that lazily loads a node's children the first time it is expanded.

Merge k pre-sorted singly-linked lists into one sorted list in O(n log k) time.

Implement a function that finds the deepest common ancestor whose hiding would conceal every target element.

Implement an async map that processes an array with a bounded number of in-flight tasks.

Find the median of two sorted arrays in logarithmic time by binary-searching for the partition that splits all the elements into equal halves.

Implement an async middleware composer that chains functions Koa-style, threading a shared context through next.

Build Minesweeper with flood-fill reveal, flagging, and win/lose detection.

Build MobX-style observables with autorun and computed that re-run when the data they read changes.

Build a simplified in-memory ORM with field selection and eagerly included related records.

Build a framework-agnostic query cache with request dedup, staleTime, subscribers, and invalidation.

Build a fully accessible modal dialog with focus trapping, focus restoration, and keyboard support.

Place N queens on an N×N board so none attack another — a classic backtracking search that places one queen per row and prunes column and diagonal conflicts.

Build a nested checkbox tree where parent state reflects its children and toggling a parent cascades down.

Implement a data structure that ingests integers one at a time and reports the running median in logarithmic time.

Implement a minimal Observable with subscribe/unsubscribe and of/from plus map and filter operators.

Transform concurrent insert and delete operations so replicas converge to the same text.

Apply optimistic updates immediately and roll them back on failure, even with concurrent mutations.

Parse a truncated JSON string into the best-valid value so far by completing open strings and containers.

Build an immutable list where every update returns a new version that shares unchanged nodes with the old one — structural sharing over a cons list.

Build progress bars that fill concurrently up to three at a time, and let the user pause and resume each one.

Build reactive state with a Proxy that tracks reads and re-runs registered effects on write.

Build a search box that caches results per query and dedupes in-flight requests.

Build a redux-saga-style interpreter that runs a generator of declarative effects and resumes it with each result.

Build a contenteditable rich-text editor with bold/italic/list formatting and a live toolbar state.

Implement a function that converts a list of styled text ranges into a canonical, properly nested HTML string.

Build a mini reactive-streams library: a cold Observable and pipeable operators composed with a .pipe() chain.

Extend a tiny schema validator to handle nested object and array shapes plus optional fields.

Build a segment tree over an array for logarithmic range-sum queries and point updates, each tree node holding the aggregate of its slice.

Build a grid where you click and drag across cells to select a rectangular range of them.

Build a replicated growable array for text whose positional-id inserts and deletes converge across replicas.

Implement a function that returns the smallest window of a string that contains every character of another string.

Build a skip list — a sorted set layered with express lanes of linked lists so search, insert, and delete run in expected logarithmic time.

Build a grid of cells with formula evaluation and dependent-cell recalculation.

Build a spreadsheet that recomputes dependent cells when inputs change and detects circular references.

Build a state-machine engine with events, guards, entry and exit actions, and context updates.

Render markdown-so-far to HTML, holding and closing unclosed bold, inline code, and fenced code blocks.

Implement structuredClone — deep-clone a value including Map, Set, Date, RegExp, typed arrays, and circular references.

Implement a slice operation over text annotated with overlapping style ranges, preserving alignment.

Implement a function that replaces a text range and keeps the surrounding style ranges normalized.

Implement a function that patches shallow style objects over a text range without clobbering unrelated keys.

Fill a 9×9 Sudoku grid by backtracking — try each digit in the next empty cell, checking its row, column, and 3×3 box, and undo on a dead end.

Implement serialize and deserialize helpers that round-trip values like Date, Map, Set, and BigInt through JSON.

Build serialize and deserialize that preserve referential identity — shared references and circular structures round-trip intact.

Implement a function that walks an HTML document's headings and builds a nested table of contents.

Build a fully accessible tabs component with arrow-key navigation per the ARIA authoring guide.

Extend a tiny test runner so it correctly awaits asynchronous specs and asynchronous setup or cleanup hooks.

Build Tetris with falling tetrominoes, rotation, line clears, and scoring.

Implement a function that gathers the text content lying between two DOM nodes in document order.

Build a generalized tic-tac-toe game on an N x N board where M consecutive marks wins.

Compute a tooltip's position around an anchor, flipping and shifting to stay inside the viewport.

Implement a function that returns a topological ordering of nodes in a directed acyclic graph.

Build a transfer list with bulk select, deselect, and the ability to add new items to either side.

Build a class that tracks draft values and commits them as batch checkpoints for undo and redo navigation.

Build a user database that buffers draft mutations and commits them as batch undo and redo checkpoints.

Implement a hook returning a debounced callback with cancel and flush, always calling the latest function.

Implement a pointer-based drag hook that tracks an element's x/y offset with start/move/end handlers.

Implement a form-state hook managing values, touched, errors, validation, and submission.

Implement a hook that loads more pages when a sentinel element scrolls into view, guarding against duplicate loads.

Implement a hook that reports a ref'd element's content-box size via ResizeObserver.

Implement a stale-while-revalidate data hook with an in-memory cache, dedup, and revalidation shared across components.

Implement a hook returning a throttled version of a callback that runs at most once per interval, with leading/trailing calls.

Implement an undo/redo state hook exposing undo, redo, canUndo, canRedo over past/present/future stacks.

Implement a windowing hook that renders only the visible rows of a long list, with correct spacer offsets.

Implement a WebSocket hook exposing connection status, last message, and send, with auto-reconnect and cleanup.

Compute the visible slice and spacer offsets to render only on-screen rows of a huge list.

Build a windowed list that renders only the visible rows of a large dataset for smooth scrolling.

Decide whether a string matches a pattern containing `?` (any single character) and `*` (any sequence) — a two-dimensional dynamic-programming match over string and pattern.

Build the Wordle word-guessing game with row-by-row guesses and per-letter color feedback.