Skip to content
DevFlash

System design

System design: structuring an architecture interview answer

A method for connecting requirements, interfaces, services and operations in an architecture discussion.

  • 5 min read
  • 5 sections
  • Updated November 2, 2026

This guide is under editorial review.

In 1 minute

  • Start with the user’s action, rules and scope boundaries.
  • Estimate when it affects choices and trace a full request before adding components.
  • Explain consistency, safe retries and failures, ending with a decision and its limitations.

System design is a discussion about turning a need into components, flows and justified decisions. In an interview, a diagram helps when it explains who uses the system, what happens to data and which behavior the design provides. You do not need to start with a database, framework or cloud service. Start by understanding the problem and agreeing on the areas worth exploring.

This guide covers the whole system, from browser to persistence and operations. For interface-specific decisions, continue with front-end system design. Practice with one simple product, such as appointment booking, and keep that example throughout the discussion. Switching products for each decision makes contradictions harder to spot.

Starting a system design interview

  1. Restate the action

    Restate the request as an action: someone checks available appointments, selects one and receives confirmation.

  2. Discover the rule

    Ask who publishes availability and whether two people can compete for the same slot. That identifies an important rule before you draw anything.

  3. Delimit scope

    State exclusions, such as payments or waiting lists, if they are not required. An explicit boundary lets you proceed without pretending every problem is solved.

  • Identify the user, goal and primary action.
  • Separate confirmed requirements from your assumptions.
  • Agree on one flow to explore before adding others.
  • Leave time to explain limitations and future changes.

As part of technical interview preparation, ask about the format, shared drawing tools, duration and expected depth. Those details shape your presentation but do not replace questions about the product.

Four rising steps with a requirements list, a calculator, a box diagram and a magnifier on one box.
Clarify requirements, estimate when it changes a choice and detail responsibilities along the main flow.

Requirements, scale and constraints

Separate functions from desired properties. Booking an appointment is a function; preventing duplicate confirmations is a consistency rule. Response time, availability and retention are constraints to clarify. Ask which operations must remain available during partial failure. Reading a schedule might tolerate temporarily stale data, while confirming a booking requires checking availability at the authoritative source.

Estimate only when a number affects a decision. Label numbers as exercise assumptions, never as company facts. When estimating traffic, distinguish active users, actions per user and peak concentration. A daily average alone cannot describe a sudden booking window. Explain which future measurement would validate your assumption and which component would be affected first if it were wrong.

Components and data flows

Draw the client, API entry point, booking logic and storage. Walk through a complete write before adding caches or queues. The browser sends intent; the server authenticates, authorizes and checks availability; persistence records the reservation. Show where uniqueness is enforced atomically. A client-side check improves the experience but cannot prevent concurrent requests from booking the same appointment.

Then describe the read path and its differences. A cache can reduce queries but needs keys, freshness rules and a strategy for stale data. A notification queue separates delivery from confirmation, but requires failure and duplicate-processing handling. Compare these choices with the system design examples. Give each component an explained responsibility instead of creating services by habit.

Contracts and failure behavior

A contract states what consumers can assume. Here, a confirmed reservation has an identifier, while a rejected attempt carries an expected reason. The type documents the response; the server still needs input validation and rule enforcement. Also explain how a timeout differs from rejection: the operation may have completed even when its response never reached the client.

type BookingResult =
| { status: "confirmed"; bookingId: string }
| { status: "rejected"; reason: "unavailable" | "invalid" };
function bookingMessage(result: BookingResult): string {
if (result.status === "confirmed") {
return `Booking ${result.bookingId} confirmed`;
}
return result.reason === "unavailable"
? "Choose another appointment"
: "Check the booking details";
}

Do

  • For safe retries, discuss an idempotency key tied to the logical attempt and persisted by the server. Define behavior when the same key arrives with different data.
  • Preserve the user’s selection and offer a status check before encouraging another booking.

Avoid

  • Retrying every failure automatically: authorization and input errors need different actions.

Alternatives, operations and evolution

Compare alternatives against the requirements they serve. A simple deployment can ease initial maintenance; separating heavy processing may protect interactive requests. Explain communication, observability and recovery costs for each option. Operationally, track booking failures, latency and queue size without logging unnecessary personal information. An alert should suggest an actionable investigation rather than merely report that a number increased.

Use the technical assessment criteria to review your explanation. Can you trace an entire request? Explain a lost response? Distinguish an assumption from a requirement? Those checks reveal more useful gaps than memorizing technology names.

Frequently asked questions

What is system design in an interview?

It is an architecture discussion grounded in a product problem. You explain requirements, components, data and decisions, including concurrent use and failure. The agreed scope determines the depth.

How do I start a system design problem?

Restate the goal, identify the user and confirm the main flow. Separate requirements from assumptions, then draw the minimum data path. Discuss optimizations after establishing the need they address.

Do I need scale calculations in every interview?

No. Ask whether volume matters for the exercise. If it does, use simple calculations with explicit assumptions and connect the result to a decision. Avoid precise figures that change nothing.

How can a front-end developer study system design?

Start with familiar interface flows and follow requests beyond the API. Study contracts, persistence and failures alongside state and rendering. Practice identifying where browser responsibility ends and server responsibility begins.

Practice with real tests

Solve front-end exercises in the browser, with the same tests a reviewer would run.

See the exercises