On this page

What is a frontend system design interview?

How is it different from a backend system design interview?

What do interviewers grade in a frontend design round?

How should you use the 45 minutes?

What topics does a frontend system design interview cover?

Choosing where the page is rendered

Designing the API a screen needs

Client state and caching

Real-time updates

Performance and Core Web Vitals

Accessibility

Security in the browser

Common frontend system design interview questions

What does a strong answer sound like?

How do answers differ by level?

Frontend vs backend system design interview

How to prepare for a frontend system design interview

Frequently asked questions

Related reading

Frontend System Design Interview: What It Asks and How to Answer It

Image
Arslan Ahmad
A frontend system design interview asks you to design what runs in the browser: rendering, data, client state, real-time updates, performance and security.
Image

What is a frontend system design interview?

How is it different from a backend system design interview?

What do interviewers grade in a frontend design round?

How should you use the 45 minutes?

What topics does a frontend system design interview cover?

Choosing where the page is rendered

Designing the API a screen needs

Client state and caching

Real-time updates

Performance and Core Web Vitals

Accessibility

Security in the browser

Common frontend system design interview questions

What does a strong answer sound like?

How do answers differ by level?

Frontend vs backend system design interview

How to prepare for a frontend system design interview

Frequently asked questions

Related reading

A frontend system design interview asks you to design the part of a product that runs in the browser. That covers how the page is delivered and rendered, how it gets and keeps its data, and how it stays fast, accessible and secure on devices the team does not choose. The interviewer usually treats the servers as a system that already works and asks you for the API the screen needs.

A strong answer follows a fixed order of five steps, states its targets in numbers, and spends its longest block on the part where the design is tested against those numbers. The rest of the answer is judged on four separate axes: how you scope the problem, how sound the design is, how deep your knowledge goes, and how easy you are to follow.

This article explains what the round covers, how it differs from a backend round, what interviewers grade, how to use the 45 minutes, which topics come up, and how the same answer changes from mid-level to staff.

What is a frontend system design interview?

A frontend system design interview is a design round for web engineers, usually 45 to 60 minutes long, in which you design a user interface and the client code behind it. The question names a component, such as an autocomplete, or a whole product, such as a news feed or a chat app.

Questions arrive in one of three sizes. Scope means how much of the system the question asks you to design, and naming it early tells the interviewer where your design starts.

ScopeWhat you designExample
One componentIts inputs, events, states and keyboard behaviorA search box with suggestions
One application, API givenRendering, state, data fetching, performanceA product list and cart
Application plus its APIAll of the above, plus requests and response shapesLive order tracking

How is it different from a backend system design interview?

A backend round asks about many users at once: how many servers handle the busiest hour, where the data is stored, and what keeps the service running when a machine fails. A frontend round asks about one user on one screen, and most of what that user waits for happens in the browser.

Consider an online grocery store's product list that asks the server for 30 products. The server finds them in 80 ms. On a mid-range phone with a slow mobile connection, the shopper still waits about 3.7 seconds before the first product appears. The figures below use the slow mobile profile from Google's Lighthouse tool. It has a 150 ms round trip, the time for a message to reach the server and for the reply to come back, and about 200 KB per second of download speed. The code size and its run time are reasonable assumptions for a page of this kind.

Where 3.7 seconds go on a slow phone: the server's 80 ms is about 2 percent of the wait

The server's work is about 2 percent of that wait. The other 98 percent is spent opening a connection, downloading 400 KB of JavaScript, running that code, and drawing the page. Adding servers shortens none of it, which is why a frontend design is a different subject and not a smaller backend design.

Three other differences shape the answers. The frontend runs on whatever device the user owns, so the design names a target device and network in numbers. All of the page's code, layout and input handling share one main thread, a single line of work, so any task that holds it for more than 50 ms (a long task) delays every tap that arrives during it. Finally, a release does not reach every user at once: a tab opened before the release keeps running the old code, so the previous release's files and API shapes must keep working for a time.

What do interviewers grade in a frontend design round?

Many companies grade a design round on a short list of separate qualities, so that one strong area cannot hide a weak one. The names differ between companies, but four are common:

  • Problem navigation. How you turn an open question into a scoped problem: the questions you ask, the assumptions you state, and how you use the time.
  • Solution design. Whether the parts fit together and meet every requirement, including the components, the data flow, the interface and the loading and error states.
  • Technical depth. Whether you know the mechanism behind each choice and its cost, at the depth the role needs.
  • Communication. Whether the interviewer can follow your answer and redirect it, through structure, drawing, summaries, and the way you take hints.

Each axis usually gets one of three marks for the level being hired: below, meets, or exceeds expectations.

How should you use the 45 minutes?

A frontend design round is usually booked for 45 minutes, but introductions take about 5 minutes and most interviewers keep about 5 minutes at the end for your questions. That leaves about 35 minutes for the design, divided across five steps that each produce something concrete:

  1. Requirements. The actions a user takes, and four to six quality targets in numbers.
  2. Architecture. A box diagram of the client parts, with every arrow labeled by what travels on it.
  3. Data model. The entities the client keeps and the shape of its store.
  4. Interface. The key requests and responses, and the props and events of one important component.
  5. Optimizations. Performance, accessibility, security, monitoring, and the area the interviewer chooses.

A time plan for the 45-minute frontend design round, with checkpoints at minute 18 and minute 30

The order matters because each step uses what the step before produced. A component tree drawn before the requirements are known often has to be drawn again.

The two checkpoints in the plan are the useful part. At minute 18 the architecture should be finished, and at minute 30 you should be starting the optimizations. Optimizations get the longest block because that is where two correct answers usually differ.

State your assumptions as a visible list with numbers. For example: 4,000 products, 30 results per page, a mid-range phone on a slow network with a 150 ms round trip, and keyboard and screen reader support. Then say aloud what would change if the most important one were wrong.

When the interviewer points at an area, answer in four moves. Restate the problem with a number, name two options, choose one and tie it to a requirement, then name its cost and how you would measure it. End each step with a one-sentence summary and a question, so the interviewer can redirect you early.

What topics does a frontend system design interview cover?

The same seven areas appear in almost every question. Most answers need only two or three of them in depth, so the skill is recognizing which ones the question depends on.

Choosing where the page is rendered

Rendering means producing the page structure that the browser turns into pixels. With client rendering, the server sends a nearly empty page and JavaScript builds it. With server rendering, the server sends finished HTML, and JavaScript then attaches event handlers to it, a step called hydration.

The difference is large on a slow phone. In a throttled headless Chrome lab (150 ms round trip, about 1.6 Mbps, and the CPU slowed four times), a 30-product list appeared after 1,516 ms with client rendering and after 264 ms with server rendering. The server-rendered buttons, however, responded only from 1,296 ms, because hydration still had to download and run the code. A good answer names both numbers: server rendering shows content sooner, but the page is not usable until hydration finishes.

Designing the API a screen needs

The frontend design proposes the requests that suit the screen: one request or five, 30 items per page or all 4,000, and which fields each item carries. A response should contain only what the screen shows, plus the totals and the next page marker the screen needs. For long lists, the server can return a marker for the next page instead of a page number (cursor pagination). That keeps results stable when new items are added at the top.

Client state and caching

State is the data the page holds while it is open, such as the product list, the cart and the text in the search box. The design decides where each piece lives. The search query belongs in the URL so that a shared or reloaded page shows the same results. Server data belongs in a cache keyed by the request, and each item is stored once under its id, so a price change appears the same everywhere. An optimistic update shows a change at once and reverses it if the server rejects it.

HTTP caching belongs here too. Code files with a hash in their names can be cached for a year, while the HTML that names them must stay short-lived. A CDN, a set of servers in many cities that keep copies close to users, may store shared responses but never one user's private data.

Real-time updates

Live data arrives in one of three ways. Polling means asking the server again at a fixed interval. Server-sent events (SSE) keep one connection open on which the server pushes updates in one direction. WebSockets keep a connection open in both directions.

Choose with numbers. Suppose 20,000 order tracking pages are open at the busiest hour. Polling every 10 seconds sends 2,000 requests per second, and most replies contain nothing new. If 5,000 of those orders are out for delivery and each driver position changes every 10 seconds, a stream that sends only changes carries about 500 messages per second. SSE suits that one-way flow. A chat app or a collaborative editor, where the client also sends a steady flow of messages, suits WebSockets.

Performance and Core Web Vitals

Google's Core Web Vitals are three measurements of real visits, each judged at the 75th percentile. Largest Contentful Paint (LCP) is how soon the largest image or text block appears, and it should be 2.5 seconds or less. Interaction to Next Paint (INP) is how quickly the page shows a response after a tap or key press, and it should be 200 ms or less. Cumulative Layout Shift (CLS) is how much visible content moves on its own, and it should be 0.1 or less.

Turn these into requirements early and tie each optimization to the metric it protects. In the same lab, sending 400 KB less JavaScript before a product list moved the list from 2,883 ms to 866 ms, which is what 400 KB costs at about 200 KB per second. In another lab run with the CPU slowed four times, scoring 4,000 products in one key press handler made every key press take 360 ms to paint. Moving that work to a Web Worker, a separate thread for scripts, brought the paint back to 16 ms or less.

Accessibility

Every interactive component must work with a keyboard and a screen reader. An autocomplete follows the combobox pattern, so focus stays in the input while the arrow keys move the highlight. A modal moves focus inside itself and returns it when closed. A live page announces important changes, such as an order status, but not every small update.

Security in the browser

The main threat is cross-site scripting (XSS), where text from a user or a server runs as code in another user's page. The defense is to insert user text as text, never as HTML, and to add a Content Security Policy, a response header that limits which scripts the page may run. Authentication tokens are safer in cookies marked HttpOnly, which page scripts cannot read, than in localStorage, which they can.

To practice all seven areas on one running example, with measured numbers and full case studies, Grokking the Modern Frontend System Design Interview covers each one before applying them to components and products.

Common frontend system design interview questions

The questions below appear often because each one tests a different part of the design. Knowing what a question tests tells you where to spend the optimization block.

  • Design an autocomplete. Tests waiting for a pause in typing (debouncing), ignoring replies that arrive out of order, and caching results by query.
  • Design a news feed. Tests cursor pagination, rendering only the visible posts (virtualization), optimistic likes, and returning the reader to the same post. A ten-minute session at one post every 4 seconds shows 150 posts, or 18,000 elements at about 120 per post.
  • Design a chat app. Tests WebSockets, message order, messages kept while offline, and reconnection without lost or repeated messages.
  • Design a data table. Tests where sorting and filtering run, rendering only the visible rows, and selection across pages.
  • Design a collaborative document editor. Tests how two people's edits merge, either through operational transformation (OT), where a server reorders and adjusts edits, or through CRDTs, data types whose copies always merge to the same result.
  • Design an AI chat interface. Tests streaming text as the model writes it, rendering incomplete formatting, and stopping an answer. Suppose the model starts after 0.8 seconds and writes 50 tokens per second. A 600-token answer then takes 12.8 seconds without streaming, while with streaming the first words appear after 0.8 seconds.

What does a strong answer sound like?

Here is a short answer to "Design the autocomplete for a store's search box", given at the level a senior role expects:

One component, with the suggestions API given. I will design for 4,000 products, a mid-range phone on a slow network, and full keyboard and screen reader use. The states are idle, loading, results, no results and error. I wait 250 ms after typing pauses and keep results in a cache by text, so pressing Backspace shows the earlier list at once. Each request can be cancelled, and a reply is shown only if its text still matches the box. The markup follows the combobox pattern, and matched letters are highlighted as text, never inserted as HTML.

The answer is short and names no framework. It scores well because it scopes the problem, states three targets, lists the states, and handles two failures that weaker answers miss: replies that arrive out of order, and keyboard users. The 250 ms wait also fits a 500 ms target for suggestions: 250 ms of waiting, plus a 150 ms round trip, plus about 50 ms of server time, is 450 ms.

A weaker answer sends a request on every key press, names libraries without the problem each one solves, and spends minutes on the search engine behind the API.

How do answers differ by level?

Levels differ in what an answer covers without being asked, not in how many technologies it names. Each level includes the one below it, so an answer that discusses team ownership but never says what the page shows when a request fails reads as less senior, not more.

How mid-level, senior and staff answers to the same tracking page question differ

Take "Design the live order tracking page" as the example. A mid-level answer splits the page into a status timeline, an estimated delivery time and a map, renders the shell on the server, and polls every 10 seconds with loading and error states. That answer is correct and complete for what the question states.

A senior answer also chooses the channel with numbers: 2,000 polling requests per second against about 500 stream messages. It resumes from the last event id after a dropped connection, and it closes the stream while the tab is hidden. It announces status changes to screen readers and loads the map code only when the order leaves the store.

A staff answer adds the other teams and the months after the launch. It proposes one real-time gateway shared with support chat, and it versions every message so that old tabs keep working. It ships behind a flag to 5 percent of orders, with polling as the fallback. It also measures support contacts per thousand orders before and after the change.

Frontend vs backend system design interview

Backend system designFrontend system design
Main questionMany users at onceOne user on one screen
Where the time goesServer work and queriesConnections, downloads, code, drawing
HardwareChosen by the teamOwned by the user, often slow
Limit that mattersServers, storage, networkOne main thread, download size, frame time
Failed requestA log line and a retrySomething the user sees
New releaseOld version gone in minutesOld code keeps running in open tabs
Typical partsLoad balancers, caches, databases, queuesComponents, state, data layer, rendering method

Many full-stack loops include both rounds, so state the boundary in the first minutes of either one and keep to it.

How to prepare for a frontend system design interview

Start with the method and the numbers. Learn the five steps and the time plan until you can follow them without notes. Then learn the numbers most answers use: the slow profile's 150 ms round trip, the 50 ms long task, the 16 ms frame, and the three Core Web Vitals limits.

Then answer one component question and one product question each week, aloud, in 35 minutes. Check each answer against the four axes, and practice the follow-up questions too, because they often decide the level.

Frequently asked questions

What is asked in a frontend system design interview? You are asked to design a component, such as an autocomplete or a data table, or a product, such as a news feed or a chat app. The interviewer expects requirements, a client architecture, a data model, the API the screen needs, and optimizations for performance, accessibility and security.

How is frontend system design different from backend system design? Backend design is about many users, servers and stored data. Frontend design is about one user on one screen: rendering, the main thread, client state, the network between the browser and the API, and the qualities every user notices. Most of the wait on a slow phone happens in the browser, not on the server.

Do I need to know React for a frontend system design interview? No. Interviewers grade the design, not the framework. Name the general pattern first, such as hydration or a client cache, and mention a framework only as one way to implement it.

How long is a frontend system design interview? Most rounds are booked for 45 to 60 minutes. In a 45-minute round, about 35 minutes go to the design after introductions and your questions at the end.

Which Core Web Vitals should I mention in the interview? Mention all three as requirements: LCP of 2.5 seconds or less, INP of 200 ms or less, and CLS of 0.1 or less, each at the 75th percentile of real visits. Then tie each optimization to the metric it improves.

What separates a senior frontend design answer from a mid-level one? A senior answer covers failures, every user's experience, and the reason behind each choice, each backed by a number. A mid-level answer builds what the question states correctly but leaves those out.

Ready to practice the whole round? Grokking the Modern Frontend System Design Interview teaches rendering, data, state, performance, accessibility and security on one running example, then applies them to UI components and full products, with graded answers at each level.

System Design Interview

What our users say

MO JAFRI

The courses which have "grokking" before them, are exceptionally well put together! These courses magically condense 3 years of CS in short bite-size courses and lectures (I have tried Grokking System Design Interview, OODI, and Coding patterns). The Grokking courses are godsent, to be honest.

Steven Zhang

Just wanted to say thanks for your Grokking the system design interview resource (https://lnkd.in/g4Wii9r7) - it helped me immensely when I was interviewing from Tableau (very little system design exp) and helped me land 18 FAANG+ jobs!

Eric

I've completed my first pass of "grokking the System Design Interview" and I can say this was an excellent use of money and time. I've grown as a developer and now know the secrets of how to build these really giant internet systems.

More From Designgurus
Annual Subscription
Get instant access to all current and upcoming courses for one year.

Access to 50+ courses

New content added monthly

Certificate of completion

$33.17

/month

Billed Annually

Recommended Course
Grokking the Object Oriented Design Interview

Grokking the Object Oriented Design Interview

61,330+ students

4.2

Learn how to prepare for object oriented design interviews and practice common object oriented design interview questions. Master low level design interview.

View Course
Join our Newsletter

Get the latest system design articles and interview tips delivered to your inbox.

Read More

12 Weeks Tech Interview Preparation Bootcamp

Arslan Ahmad

Arslan Ahmad

System Design Interview Guide for Beginners: Learn System Design Step by Step

Arslan Ahmad

Arslan Ahmad

How to Design a Video Conferencing System (Zoom Architecture)

Arslan Ahmad

Arslan Ahmad

Mastering the Meta Technical Screen: A Comprehensive Guide for Senior Software Engineers

Arslan Ahmad

Arslan Ahmad

Design Gurus logo
One-Stop Portal For Tech Interviews.
About Us
Our Team
Careers
Partners
Contact Us
Become Affiliate
Copyright © 2026 Design Gurus, LLC. All rights reserved.