In 1 minute
- Clarify users, devices, search and sharing before choosing libraries.
- Separate local state, URL filters and remote data, avoiding unnecessary copies.
- Describe data flows and interface behavior during failures and updates.
Front-end system design means organizing an interface around interaction, data and delivery requirements. You need to explain where responsibilities belong and how the screen behaves before, during and after a request. A component diagram that omits error states, navigation and accessibility leaves part of the problem unanswered.
Use a catalog with filters, details and favorites as your scenario. The goal here is to choose boundaries and contracts without implementing an entire product. The general system design guide covers services and persistence more broadly. Focus on what people see and can do, including on a slow connection or when navigating back through browser history.
Scoping a front-end system design problem
Confirm context
Confirm who uses the catalog, which devices matter and whether search engines need to discover pages.
Define filters
Ask whether filters should survive a reload and whether a search can be shared through its URL.
Distinguish favorites
Distinguish device-local favorites from account favorites. These answers affect storage, rendering and dependencies; picking a library first can solve the wrong problem.
- List primary actions and observable states.
- Record navigation and sharing requirements.
- Define empty-data and offline behavior.
- Separate browser responsibilities from server decisions.
Declare a first version: browse, filter and open details. If favorites come later, explain how that reduces scope. Do not promise offline synchronization or live updates without discussing their costs and necessity.
Components and responsibility boundaries
Divide the interface by responsibilities that change together. A route coordinates filters and data, a list presents results, and an item displays information and emits intent. An item component need not know about authentication, caching and transport. Extracting every line of markup into a separate component, however, makes the flow harder to follow without creating a useful boundary.
Explain each part's inputs, outputs and state owner. Pass data and callbacks when the path is short. Consider context when distributed consumers share a dependency. The React interview questions explore composition, but your design should remain understandable to someone using another framework. Name product responsibilities before mentioning hooks.
Local state, URL state and remote data
Do
- Keep panel visibility near its controlling component.
- Put shareable filters and sorting in the URL, with defaults and validation.
- Treat API data as a temporary representation of server data.
Avoid
- Automatically copying responses into another local state value: two copies create uncertainty about which should appear after an update.
Define a query key that includes every parameter that changes the result. Distinguish initial loading from background refresh. If old results remain visible during a new search, indicate that they do not yet match current filters. This contract describes query states without prescribing a library or supplying the complete interaction.
type CatalogItem = { id: string; title: string };type CatalogState =| { status: "loading" }| { status: "error"; message: string }| { status: "ready"; items: CatalogItem[]; refreshing: boolean };function resultCount(state: CatalogState): number | null {return state.status === "ready" ? state.items.length : null;}

Rendering, loading and performance
Decide what belongs in initial HTML and what depends on interaction. Stable public content may benefit from server rendering; interactive controls still need client behavior. Consider hydration work, JavaScript size and image loading. Server rendering does not automatically eliminate browser work or guarantee a fast screen.
Before proposing virtualization, ask how many elements are displayed and what slowdown has been observed. Pagination can simplify navigation and reduce volume. Virtualization requires attention to focus, assistive reading and in-page search. Reserve space for images and messages to prevent unexpected shifts. Explain how you would measure initial loading and filter responsiveness under realistic user conditions.
Contracts, failures and accessibility
Agree with the server on response shape, pagination, errors and permissions. Hiding a button does not replace authorization. For favorites, discuss whether to show success before confirmation: optimistic updates improve perceived responsiveness but require recovery when writes fail. Preserve context rather than clearing the entire list because one item failed.
Include keyboard access, accessible names and result announcements in the initial proposal. When opening details and returning, consider predictable restoration of scroll position and focus. Do not move focus on every network response. Compare these flows with the system design examples, especially when responses arrive in an unexpected order.
Validating and evolving the proposal
Walk through three stories: first visit, a filter with no results and a failed favorite update. For each, explain the state change, request and user feedback. This exposes hidden dependencies and overloaded components. In a front-end technical interview, you can also use a real portfolio screen to explain why you chose a different boundary.
Frequently asked questions
What is front-end system design?
It is the design of interface structure, state and data flows. The discussion connects components, networking, rendering, navigation and accessibility to product requirements without requiring a complete implementation.
How do front-end and back-end architecture interviews differ?
Front-end discussions focus on client experience and interface delivery. Back-end discussions focus on services, persistence and operations. Contracts between them remain a shared concern.
How do I choose where state belongs?
Ask who reads the value, who changes it and how long it should survive. Local state, URLs and remote caches serve different needs. Answer those questions before choosing a global store.
Must I choose a framework in a system design answer?
Only when the prompt requires it or the choice clarifies a concrete constraint. Start with behaviors and responsibilities, then explain how the tool supports those boundaries and what it costs.
Practice with real tests
Solve front-end exercises in the browser, with the same tests a reviewer would run.
See the exercises