skip to content

In a frontend design round for a hotel-booking web app, how do you turn 'it must be fast and accessible' into requirements that change the design?

level: middleimportance: should knowfreq 57%

answer

  1. a number, a percentile, a device
  2. LCP, INP, CLS at the 75th
  3. judge the segment your users are in
  4. trace each target to a stage
  5. accessibility stated up front, not audited

basics

~20 s

Make each one measurable for the real users: Core Web Vitals targets at the 75th percentile on mobile, and a commitment that keyboard and screen-reader users can book. Then trace each target to a concrete choice in the design.

solid answer

~50 s

'Fast' becomes the Core Web Vitals 'good' targets: LCP within 2.5 s, INP at most 200 ms, CLS at most 0.1, judged at the 75th percentile of page loads, and I'd judge the mobile segment because half the traffic is low-end phones. Then each target lands somewhere. LCP: the first results and the hotel's lead photo come in the first response, sized for a phone. INP: a filter tap updates the list without redrawing the map and every result. CLS: space is reserved for photos and prices that arrive late. 'Accessible' becomes a stated commitment that keyboard and screen-reader users can search, compare and book, so the results list is a full alternative to the map, the carousel works without a pointer, and each booking step moves focus and announces errors. What full conformance demands is accessibility work; stating it is what shapes the design.

go deeper

for a junior

Recall the three Core Web Vitals and their good targets: LCP 2.5 s, INP 200 ms, CLS 0.1, each judged at the 75th percentile of page loads.

for a middle

Explain how each target becomes a choice: what the first response carries, what work a tap triggers, which space is reserved, which non-pointer path exists.

for a senior

Choose the segment that matters for this product and defend it, and say what you would trade when two requirements pull apart, such as a rich map against INP on cheap phones.

for a principal

Turn the round's requirements into budgets a team can own after launch: per-page targets, a script budget and an accessibility commitment with someone accountable for each.

## Why a vague requirement scores nothing In the requirements stage of a **frontend system design round**, candidates often write "fast, accessible, works in many languages" and move on. Those words are true of every product, so they change nothing on the board. A **non-functional requirement** (a quality the product must have, as opposed to a feature it must offer) earns its place only when it is stated so that it can be checked and then traced to a decision. Two steps: 1. **Make it measurable for the real users**: a number, a percentile, a device class. 2. **Trace it to a stage**: name the architecture, data-model, interface or deep-dive choice it forces. ## Making "fast" measurable The published yardstick for page experience is the **Core Web Vitals**, each with a "good" target: | Metric | Measures | "Good" target | "Poor" beyond | |---|---|---|---| | **LCP** (Largest Contentful Paint) | When the main content appears | 2.5 s or less | 4 s | | **INP** (Interaction to Next Paint) | How quickly the page responds to taps, clicks and keys | 200 ms or less | 500 ms | | **CLS** (Cumulative Layout Shift) | How much visible content jumps around | 0.1 or less | 0.25 | Each is judged at the **75th percentile of page loads**, split by mobile and desktop, so the target holds for most visits, not a typical one. INP replaced the older first-input metric as a Core Web Vital in 2024. **TTFB** (time to first byte) is not a Core Web Vital; the guidance treats 0.8 s or less as good and above 1.8 s as poor, and a slow first byte pushes everything after it back. For a hotel-booking app where half the traffic is low-end phones on flaky networks, the honest statement is: *"LCP, INP and CLS 'good' at the 75th percentile on mobile, on the results and hotel pages."* Naming the segment matters: a target met on a developer's laptop says nothing about these users. ## Tracing each target into the design | Requirement | Where it lands | Consequence for the hotel-booking app | |---|---|---| | LCP 2.5 s on mobile | Architecture | The first results and the hotel's lead photo arrive in the first response, not after several round trips | | LCP 2.5 s on mobile | Interface | Image URLs come in sizes for a phone's screen; the search call returns one page of results | | INP 200 ms on low-end phones | Architecture | A filter tap updates only the list and the affected pins; the map loads after the list | | CLS 0.1 | Data model and views | Photo dimensions and price slots are known up front, so space is reserved before they load | | Flaky network | Interface | The booking submit can be retried without booking twice | The table is the answer the interviewer is listening for: every target names a choice, and every choice names its target. ## Making "accessible" a requirement Accessibility is stated as a commitment the business makes, such as *"keyboard and screen-reader users can search, compare and book, to the conformance level we commit to"*, and then turned into screen-level consequences: - the **results list** offers every hotel the **map** shows, so the map is never the only path; - the **photo carousel** has controls that work without a pointer; - each **booking step** moves focus to its heading, and errors are tied to their fields and announced; - the **right-to-left** language and the others keep the same structure, so assistive technology reads them correctly. How to meet the commitment in detail (conformance criteria, testing, screen-reader behaviour) is separate accessibility work. In the round, stating it early is what changes the design; adding it as a final audit changes only the bug list. ## Other requirements, the same way - **Eight languages, one right-to-left** becomes: no hard-coded strings, per-locale formatting of prices and dates, layout by start and end. - **Flaky networks** becomes: small payloads per screen and a booking form that survives a failed request. - **Organic search** becomes: landing pages whose main content is in the first HTML. ## Saying it in the round 1. Propose the measurable version yourself and ask the interviewer to adjust it. 2. Write it on the board next to the functional requirements. 3. As you draw each later stage, point back to it: "this is for the INP target". 4. When two requirements pull apart, a rich map against INP on cheap phones for example, say which one wins for this product and what it costs.

  • Why the 75th percentile rather than the average page load?
    Because the published guidance judges a page at the 75th percentile of page loads, split by mobile and desktop, so most visits meet the target rather than a typical one on a fast machine. An average hides the slow quarter, which for this product is exactly the low-end phones on flaky networks the requirements say we serve.
  • Would you state time to first byte as one of the targets?
    Not as a Core Web Vital, because it is not one. It is a supporting number: the guidance treats 0.8 s or less as good and above 1.8 s as poor, and a slow first byte pushes LCP back. I'd raise it when a deep dive weighs rendering on the server, which can raise it while bringing content forward.
  • How do you state accessibility without turning the round into an audit?
    One line in the requirements (keyboard and screen-reader users can search, compare and book, to the level the business commits to), then one consequence per screen: a list alternative to the map, a carousel operable without a pointer, focus moves and announced errors in the booking steps. The detail of conformance is separate work.

  • Writes 'the app should be fast' and moves on without a number.
  • Quotes First Input Delay as the current responsiveness Core Web Vital.
  • Checks performance on a developer laptop and calls the target met.
  • Treats accessibility as a final audit rather than a requirement that shapes screens.
  • States targets but never says which design choice each one changes.