State interview questions

Build an accordion component with stacked sections whose content panels expand and collapse on click.

Build an autocomplete input that filters a static list and lets you pick a suggestion.

Build a textarea with a live character counter that warns as it nears a maximum length.

Build a swatch color picker where clicking a swatch selects it and previews the chosen color.

Build a button that copies text to the clipboard and shows a transient copied confirmation.

Build a countdown timer that ticks down from a start time and can start, pause, and reset.

Build a counter component that increments a displayed number each time a button is clicked.

Build a list of FAQ questions that each expand to reveal an answer on click.

Build a Like button that toggles between liked and unliked states with matching visual feedback.

Build a reusable modal dialog component that you can open from a trigger and close with a button.

Build pagination controls with previous/next and numbered pages that report the current page.

Build a password field with a live strength meter that scores the input as you type.

Build a progress bar component that visualizes the percentage completion of an operation.

Build a component that renders a list of progress bars which animate from empty to full as they mount.

Build a segmented control where clicking a segment selects it and highlights the active option.

Build a toast that appears on trigger and auto-dismisses after a few seconds, with manual close.

Build an on/off toggle switch that flips state on click and slides its knob to reflect it.

Build a tooltip that shows on hover/focus of a trigger and hides on leave/blur.

Build a traffic light that cycles green to yellow to red on a timer and loops indefinitely.

Implement a hook that exposes a boolean value alongside setTrue, setFalse, and toggle helpers.

Implement a hook that exposes a numeric count along with increment, decrement, and reset helpers.

Implement a hook that returns the current value of a sequence and advances to the next on demand.

Implement a hook that steps through an array with wraparound, exposing the current item and next/prev/set.

Implement a hook that falls back to a default value whenever the underlying state becomes null or undefined.

Implement a hook that holds an object in state and exposes helpers to merge updates or reset its value.

Implement a hook that remembers and returns the value a state held on the previous render.

Implement a hook that stores a Set in state and exposes add, delete, has, and clear helpers.

Implement a useState-like hook that also returns a reset function which restores the initial value.

Implement a hook that holds a boolean and returns a stable toggle function to flip its value.

Assign users to weighted experiment variants deterministically, with a traffic gate and independent buckets per experiment.

Build an accordion component with the correct ARIA roles, states, and properties for screen readers.

Build a carousel that auto-advances, wraps, pauses on hover or focus, and supports manual controls.

Build a two-player Connect Four game where discs fall to the lowest empty slot and four-in-a-row wins.

Implement one input component that correctly supports both controlled and uncontrolled state without leaking its reserved props.

Build a useState shared by every component that calls it, by subscribing React to a store that lives outside it.

Build a store whose subscribers each re-render only when the slice they selected changes.

Build a currency converter with two linked amount fields that recompute from an exchange rate.

Build a users data table that paginates rows with page-size and page-navigation controls.

Build a users data table that lets you sort by any column in ascending or descending order.

Build a calendar date picker that renders a month grid, navigates between months, and selects a day.

Build a dice roller that lets you pick a count of six-sided dice, roll them, and display the resulting faces.

Build a 7-segment style digital clock that updates to display the current time.

Build an accessible action menu with keyboard focus, selection, Escape, and outside-click dismissal.

Evaluate feature flags with targeting rules and a deterministic percentage rollout that stays sticky per user.

Build a file explorer that renders a nested folder hierarchy and lets you expand and collapse directories.

Build a grid of cells that light up on click and then deactivate one by one in the reverse order they were activated.

Build an image carousel that lets you page through a sequence of images with previous and next controls.

Build an image carousel with smooth slide transitions between images.

Build a job board that fetches and renders recent Hacker News job postings with paginated loading.

Build a three-column board where cards drag between columns and each column's count updates.

Implement a factory that returns a counter object with methods to read, increment, decrement, and reset its value.

Build a memory card-matching game where players flip cards to find matching pairs.

Build atom-based state with primitive and derived atoms that recompute and notify subscribers on change.

Build a Redux core with createStore, combineReducers, and applyMiddleware over a subscribe/dispatch loop.

Build a multi-select where chosen options become removable chips and the rest stay in the list.

Build a wizard form with next/back navigation, per-step validation, and a progress indicator.

Build a threaded comments tree where each comment can be replied to and collapsed recursively.

Build a notification center with an unread badge, mark-as-read, and dismiss.

Build a pixel art editor where you pick a color from a palette and paint individual cells on a grid canvas.

Build a list of progress bars that fill in sequence, each one starting only after the previous bar finishes.

Build a list of progress bars that fill concurrently with at most three running at the same time.

Build a dual-handle range slider that picks a min and max value by dragging each handle.

Implement the curried Redux middleware chain with working thunk and logger middleware.

Build memoized selectors that recompute only when their input selections change by reference.

Build two panes split by a draggable divider that resizes them within min and max bounds.

Implement an interval helper that exposes start, pause, and resume controls while preserving elapsed progress.

Build a cart where quantity changes update line totals and a grand total live.

Build reactive signals with automatic dependency tracking so computed values and effects update on change.

Build the classic snake game on a grid with keyboard control, growth on eating, and game over.

Build a list that reorders by drag or keyboard input while preserving focus and announcing each move.

Decode a Server-Sent Events stream arriving in arbitrary chunks into discrete parsed events.

Build an interactive star rating with hover preview and half-star support.

Build a star rating component where users click a star to set the rating shown by filled icons.

Build a stopwatch widget that measures elapsed time with start, stop, and reset controls.

Build a pure, immutable reducer that opens an assistant message, appends streamed deltas, and finalizes it.

Build a tabs component that shows one panel at a time based on the currently selected tab.

Build a tabs component with the correct ARIA roles, states, and properties for assistive tech.

Implement a context-backed React theme provider with stable controls, functional updates, nesting, and a strict consumer hook.

Build a two-player tic-tac-toe game that detects wins and draws on a 3x3 board.

Build a Todo List component with add and delete actions, with focus on functionality over styling.

Implement a render-props toggle component that exposes reusable state and stable controls while leaving all markup to its child function.

Build a component that moves selected items back and forth between two side-by-side lists.

Build a Turtle class that tracks position and heading as you issue movement and turn commands on a 2D plane.

Implement a class that tracks value history and exposes undo and redo navigation across the timeline.

Build a counter that keeps a history of values so you can undo and redo each change.

Build a user database class that supports CRUD operations plus undo and redo across the operation history.

Implement a hook that threads state through an async action, folding the previous state into the next and exposing a pending flag.

Implement a hook that manages an array along with helpers to push, remove, update, and clear items.

Implement an optimized useBoolean hook whose returned setters keep stable identity across renders.

Implement a hook that lets one component work both controlled and uncontrolled, deciding the mode from its props.

Implement a hook that drives a countdown timer with start, pause, and reset controls.

Implement a hook that manages a list whose items keep stable keys across inserts, removals, and reorders.

Implement a useState variant that also returns a getter for reading the newest state from inside stale closures.

Implement a hook managing an array with immutable helpers — push, removeAt, updateAt, insertAt, clear, and set.

Implement a hook that wraps a JavaScript Map with set, delete, and clear helpers backed by state.

Implement a useState-like hook that runs every incoming value through a mediator before committing it.

Implement a hook that turns a map of state transitions into bound, stable action methods over a reducer.

Implement a hook that shows an optimistic value while an update is in flight, then reconciles to the real value.

Implement a hook that manages page state over a total count, exposing page, pageCount, and next/prev/go with clamping.

Implement a hook that remembers the last value that actually differed from the current one, with a customizable comparator.

Implement a hook wrapping a FIFO queue with add, remove, clear, and first/last/size accessors.

Implement a hook whose state object you mutate directly, and reckon with what that costs React.

Build a CRUD interface to list, filter, create, edit, and delete users backed by local state.

Implement a hook that tracks a multi-select over a list, with an all/none/partial header state that stays honest.

Implement a useState variant that records value history and exposes back, forward, and go over it.

Implement a hook that drives a multi-step flow with next, previous, reset, and bounded index controls.

Implement the useSyncExternalStore shim — subscribe to an external store and read a consistent snapshot, re-rendering when it changes without missing an update.

Implement a useState that lives in the query string, staying shareable without burying the back button.

Implement a useState variant that reports whether the current value passes a validator, without an extra render.

Build the arcade game where moles randomly appear in a grid and players click them to score.

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

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

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

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.

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

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

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 framework-agnostic query cache with request dedup, staleTime, subscribers, and invalidation.

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

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

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

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.

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

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

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

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

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

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

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 form-state hook managing values, touched, errors, validation, and submission.

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

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