Frontend Engineer Interview: Rounds, Questions and Prep

Take away the framework, the component library, the linter and the hot reload, and ask a working frontend engineer to build a dropdown in a plain text editor in thirty-five minutes. That is a fair description of one round of a frontend engineer interview at a large tech company, and it is why people who ship production interfaces every week still fail it.
The frontend loop is its own thing. It shares the behavioural round and some algorithm questions with the general software engineer loop, and replaces the rest with rounds that test the platform itself: the language, the DOM, the browser, and the architecture of an application that runs on someone else's device. A backend-oriented question list prepares you for only part of it. Here is what the rounds are, how three companies arrange them, twenty-five example questions and a four-week plan.
The rounds and who runs which
Four round types make up nearly every frontend loop:
- JavaScript and DOM coding. Write a utility or manipulate a document tree, usually without a framework.
- UI component coding. Build a small working interface element.
- Frontend system design. Architect a client application on a whiteboard.
- Behavioural. The same round every engineer gets.
Some companies add general algorithm rounds, and some test web fundamentals (HTML, CSS, browser behaviour, accessibility, performance) in a round of their own, where others fold them into the coding rounds as follow-up questions.
Companies do not publish the exact arrangement. The table below summarises Prepfully's prep guide for Meta, updated in September 2026, and the community-reported pages of the Front End Interview Handbook (frontendinterviewhandbook.com) for Google and Amazon, all read in November 2026. Formats change, so confirm with your recruiter.
| Meta, as reported | Google, as reported | Amazon, as reported | |
|---|---|---|---|
| Before the loop | Recruiter call; 45-minute technical screen in a shared editor with execution turned off | Not described in these reports; ask the recruiter | Online assessment; phone screen of 45 to 60 minutes |
| The loop | Four to six interviews: two coding, one architecture and design, one behavioural | One report from a senior candidate: two algorithm rounds, one frontend round, one system design, one behavioural | Four or five rounds of about 55 to 60 minutes |
| Algorithms | Coding rounds centre on JavaScript, the DOM and async code | Candidates say general algorithm questions can appear in any round | A coding round with harder data structure problems |
| Distinctive part | An extra design round at the most senior level, sometimes replacing a coding round | Hiring committee and team match after the interviews | A separate fundamentals round; leadership principles and a Bar Raiser |
The practical reading: for Google, keep general algorithm practice in your plan, as the Google software engineer interview guide describes. For Amazon, prepare leadership principle stories for every round. For Meta, practise writing code you cannot run, because that is how the screen is reported. Candidates also report that since late 2025 one onsite coding round for software engineers comes with an AI assistant and a project you can run. Those accounts do not say whether frontend loops get it, so ask your recruiter; the Meta AI-assisted coding interview guide covers what is known.
JavaScript and DOM coding
These questions ask you to implement something the platform or a common library already provides. They test whether you understand the language under the framework.
The recurring families:
- Function utilities. Debounce and throttle, memoize, curry, once, a deep clone, a deep equality check.
- Asynchrony. Implement
Promise.allorPromise.allSettled, run tasks with a concurrency limit, retry with backoff, cancel a stale request. - Language mechanics. Implement
bind,Array.prototype.maporreduce, a simple event emitter, aclassnameshelper. - DOM traversal. Walk a tree, find a node by a rule, find the node in one tree that corresponds to a node in an identical tree, serialise a subtree.
- Events. Delegation, bubbling and capture, a custom event system.
To answer well you need closures, this and how it is bound, prototypes, the event loop with its task and microtask queues, and promise semantics, all without looking anything up. Interviewers probe at the edges: what does your debounce do with arguments and with this; what if a promise in your all rejects after another has resolved; what happens to your traversal on a tree ten thousand levels deep.
The Meta guide cited above says its screen runs in an editor with code execution turned off. Practise that way at least part of the time: write, then trace by hand with a small input, aloud. It is a different skill from running and fixing.
The UI component round
You are asked to build a component that works: an autocomplete, a tabbed panel, a modal dialog, an image carousel, a star rating, a nested checkbox tree, a data table with sorting. Some companies allow a framework of your choice, some require plain JavaScript, HTML and CSS. Ask before the day.
The first five minutes decide most of these rounds. Before writing, state what the component must do, what you will leave out, what state it holds and what events change that state. Then build the plainest version that works end to end, and only then add behaviour. Candidates who start with styling or with an elaborate abstraction run out of time holding something that does not yet function.
What is graded, roughly in order:
- It works. The main path, then the obvious edge cases: empty data, a slow or failed request, rapid input.
- Semantic markup. A button is a
button. A list is a list. This is the cheapest accessibility there is, and interviewers notice adivwith a click handler. - State kept simple. One source of truth, derived values computed and not stored twice.
- Keyboard and focus. Can it be used without a mouse? Where does focus go when the dialog opens and when it closes?
- Sensible CSS. Layout with flexbox or grid, no fixed pixel positioning that breaks when the content changes.
For an autocomplete, the follow-up questions are predictable and worth preparing as a set: debounce the input, ignore responses that arrive out of order, cache results, handle the empty and error states, support arrow keys and escape, and announce results to a screen reader.
Frontend system design
At mid level and above there is often a design round with no code, commonly about 45 minutes. It is a different exercise from backend system design. Nobody asks you to shard a database. The prompt is a client application: a news feed, a chat interface, a collaborative document editor, a photo gallery, a dashboard with live data, or a reusable component such as a data table for other teams.
A structure that holds for most prompts:
- Requirements. Core features, devices, offline or not, expected data sizes, who the users are.
- Architecture. The main components and how they are divided between server and client; rendering strategy (server rendering, client rendering, or a mix) with the reason.
- Data model and state. What lives on the client, what is cached, what is the source of truth, how server data is normalised.
- API. The calls the client makes, their shape, pagination (cursor against offset), and real-time transport where needed: polling, server-sent events or WebSockets.
- Deep dives. The two or three hard parts of this prompt. For a feed: virtualising a long list, optimistic updates, image loading. For chat: ordering, delivery state, reconnection. For an editor: conflict resolution.
- Cross-cutting concerns. Performance, accessibility, internationalisation, error handling, security such as cross-site scripting, and how you would observe it in production.
Seniority shows in step 5 and in trade-offs stated without prompting: "I would render the first screen on the server because the first paint matters most here, and accept the extra complexity in hydration." The site's overview of frontend engineering architectural patterns lists the patterns worth having names for.
Accessibility and performance questions
Whether in their own round or as follow-ups, these two subjects separate engineers who have owned a production interface from those who have only built features in one.
On accessibility, know semantic HTML and why it comes first; when ARIA attributes are needed and when they make things worse; focus management for dialogs and menus; keyboard interaction patterns for common widgets; colour contrast; labels for form controls; and how to test with a keyboard and a screen reader. The strongest signal is doing it unasked in the component round.
On performance, be able to explain how a browser turns a response into pixels: parsing, style, layout, paint, compositing. From that follow the practical questions:
- What blocks rendering, and how scripts and styles should be loaded.
- What the Core Web Vitals measure and what typically harms each.
- Why a list of ten thousand rows is slow and what virtualisation does about it.
- What causes layout thrashing and how to batch reads and writes.
- Code splitting, lazy loading, image formats and sizing, caching headers.
- How to find a slow interaction with the browser's profiler, as opposed to guessing.
Have one real story: an interface you made measurably faster, what you measured before and after, and what the cause turned out to be.
Behavioural
The behavioural round is the standard one, and frontend engineers tend to underprepare it because the technical rounds feel more urgent. Polish five or six stories in STAR form for this round, drawn from a fuller story bank. For Amazon bring more of the bank, because candidates report behavioural questions in every round.
Frontend work supplies good material if you choose it: a disagreement with a designer about what was feasible, a migration between frameworks or to a design system, a production bug that only appeared on one browser or one device, a time you argued for accessibility or performance work against a feature deadline. Pick stories where you influenced people outside engineering, since that is the part of the job this round is checking.
Twenty-five example questions
Examples written for practice, not a leaked list from any company.
JavaScript and DOM
- Implement
debounce, then add an option to fire on the leading edge. - Implement
Promise.all. - Write a function that runs an array of async tasks with at most three in flight.
- Implement an event emitter with
on,offandonce. - Given a node in one DOM tree, find the corresponding node in an identical second tree.
- Explain the output order of a snippet mixing
setTimeout, promises and synchronous logs. - Write a deep equality check that handles arrays, objects and cycles.
UI components
- Build an autocomplete that queries a remote endpoint.
- Build an accessible modal dialog.
- Build a nested checkbox tree in which parents reflect their children.
- Build an image carousel with previous and next controls and keyboard support.
- Build a table with sortable columns and pagination.
- Build a star rating that works with a keyboard.
Frontend system design
- Design the client for an infinite-scrolling news feed.
- Design a chat application's web interface.
- Design an autocomplete component for use by fifty teams.
- Design a photo gallery that works on slow mobile connections.
- Design a collaborative text editor's client.
Accessibility and performance
- A page takes six seconds to become usable on a mid-range phone. How do you investigate?
- What makes a custom dropdown accessible?
- When does adding ARIA make a page worse?
- How would you render a list of a hundred thousand items?
- Walk me through what the browser does between receiving HTML and showing the page.
Behavioural
- Tell me about a disagreement with a designer and how it was settled.
- Tell me about a frontend change you made that did not work as you expected in production.
A four-week plan
At eight to ten hours a week, for a working frontend engineer.
- Week 1: the language. Implement the utilities in the JavaScript section from memory, one or two a day, in a plain editor without running them first. Reread the parts of the language you have delegated to a framework: closures,
this, prototypes, the event loop. - Week 2: components. Build six components in plain JavaScript, HTML and CSS, 35 minutes each, with keyboard support. Then rebuild two in your framework of choice at the same pace. If your target company asks algorithm questions, begin 30 minutes a day of those.
- Week 3: design and fundamentals. Four frontend system design prompts, 45 minutes each, aloud, using the six steps. Write one-page notes on rendering, the Core Web Vitals and accessibility patterns. Draft your behavioural stories.
- Week 4: rehearsal. One mock of each round with another person. Repeat whichever went worst. Keep the daily algorithm practice if it applies.
A component built alone never gets interrupted with "what if the request fails" at minute twenty, and a design explained to an empty room is never challenged. Both rounds are worth rehearsing with someone who interviews engineers; the mock interviews guide explains how to set one up with a peer, and a coding interview coach can run the rounds at the pace and standard of a real loop.
Where coaching fits
Book a mock for the round you find hardest to judge yourself, which for most frontend engineers is system design or the live component build. On techinterview.coach, nine of the 40 coaches list coding interviews as a specialty as of November 2026, and two list frontend engineering; start from the coding interview coaches page and check a coach's profile for frontend experience before you book. For talking through code aloud, the practice interview has a coding talk-through round with an AI interviewer and a written recap. It is free; sign in to start.
Related guides
- Frontend engineering architectural patterns: names and short descriptions of the patterns the design round draws on.
- Mock interviews guide: how to run a realistic rehearsal, with a peer or a coach.
- AI in coding interviews: which companies allow an assistant in coding rounds, as of this month.
- Google software engineer interview: the algorithm rounds a Google frontend candidate should still expect.
- System design interview questions by level: for loops that include a general design round as well.
- The STAR method: the form for the behavioural round.