In a frontend system design round, what does each stage of the RADIO frame produce when the product runs in a browser?
answer
- something on the board per stage
- architecture is the client's, server one box
- views, client store, data access layer
- server-originated versus client-only data
- interface: HTTP calls and component inputs
basics
~20 sRequirements give a list of functional and non-functional needs; architecture, a client diagram with the server as one box; data model, entities tagged by origin; interface, HTTP calls plus component inputs and events; deep dives, one or two key areas.
solid answer
~50 sEach RADIO stage should leave something on the board. **Requirements**: the core flows in scope plus the non-functional needs: devices, network, accessibility, languages, indexing. **Architecture**: the *client's* diagram, meaning views, a client store for data several views share, a data access layer that talks to the server, and the server drawn as a single black box. **Data model**: the entities each view needs, each tagged as server-originated, client data to be persisted, or ephemeral UI state. **Interface**: the server-client calls (method, path, parameters, response) *and* the inputs and events between the main components. **Optimizations and deep dives**: one or two areas this product lives or dies by. The frame's authors suggest roughly 10 / 20 / 10 / 20 / 40 % of the session, but it is a checklist you revisit, not a fixed sequence.
code
pseudocode · 6 lines# Data model for a hotel-booking web app, tagged by origin
Hotel origin=server fields: id, name, location{lat,lng}, rating, photos[], amenities[]
RoomOffer origin=server fields: id, hotelId, roomType, price{amount,currency}, cancellationPolicy
SearchPage origin=server fields: results: HotelSummary[], totalCount, nextCursor
BookingDraft origin=client persisted at submit: offerId, guest{name,email,phone}, specialRequests
UiState origin=client ephemeral: carouselIndex, filterPanelOpen, hoveredHotelIdgo deeper
Recall the five letters and one artifact per stage: a requirements list, a client diagram, an entity table, the calls and component inputs, and one or two deep dives.
Explain why the diagram is the client's and why the data model splits server-originated entities from client-only state; show both halves of the interface for a real product.
Use the frame flexibly: revisit a stage when a requirement shifts, keep the server a black box unless asked, and steer toward deep dives the requirements justify.
Treat the five artifacts as a team's design-review vocabulary too: frontend design documents built on them become comparable, reviewable and easier to challenge.
## What RADIO is, read for a browser product **RADIO** is a mnemonic for running an open-ended design round: **R**equirements exploration, **A**rchitecture (high-level design), **D**ata model (core entities), **I**nterface definition (API), and **O**ptimizations and deep dive. The frame itself is not specific to frontend work, but a **frontend system design round** reads every letter differently from a back-end round. The interviewer wants to see how you structure the *client* (the code running in the user's browser) and its boundary with the server, not how you scale a fleet of services. The useful habit is to know what each stage should leave on the board. Take a **hotel-booking web app** as the running example: a search-results page with filters and a map, a hotel page with a photo carousel and room options, and a three-step booking form. | Stage | What it produces in a frontend round | What a back-end round would produce instead | |---|---|---| | Requirements | Core flows in scope, plus non-functional needs: devices, network, accessibility, languages, indexing | Similar list, plus traffic and storage figures | | Architecture | The client's parts and how data flows between them; the server is one box | Load balancers, services, databases, queues | | Data model | Entities in the client, tagged by origin | A database schema | | Interface | Server-client calls **and** inputs and events between components | Calls between services | | Optimizations / deep dives | Performance, user experience, accessibility, internationalisation, indexing | Scalability, consistency, availability | ## R: requirements on the board Requirements produce a short written list both of you can point at later: - **Functional**: search hotels by destination and dates, filter and see results on a map, open a hotel, choose a room, book in three steps. - **Non-functional**: who uses it and on what devices, how good the network is, which languages (and whether one is right-to-left), what accessibility the business commits to, whether pages must be found through search engines, how much data one screen shows, whether anything must work offline. - **Out of scope**: say it explicitly, for example reviews or loyalty accounts. ## A: the client's diagram The architecture is the **client's**. A common shape has four kinds of box: 1. **Server**: one box exposing HTTP endpoints. Treat it as a black box unless the interviewer asks otherwise. 2. **Data access layer**: makes the requests, caches responses and reports errors, so the rest of the client does not care where data comes from. 3. **Client store**: data several views share, such as the current search and the booking in progress. 4. **Views**: the results page with its filter panel, results list and map; the hotel page with its carousel and room list; the booking steps. Arrows carry labels saying what data crosses them. After drawing, say what each box is responsible for. A small product may not need every box; a single widget can keep its data inside itself. ## D: where each piece of data comes from The data model is the client's **application state**, not a database schema. Tag each entity by origin: - **Server-originated**: hotels, room offers with prices, a page of search results. - **Client-originated, to be persisted**: what the guest types into the booking form, sent to the server when they book. - **Client-originated, ephemeral**: which carousel photo is showing, whether the filter panel is open. Losing it when the tab closes is acceptable. That tagging tells you later what to fetch, what to send and what can be lost. ## I: two kinds of interface The interface stage covers **both** halves: - **Server-client**: for each call, the method and path, the parameters and the response shape, for example a paged search request carrying destination, dates and filters. - **Client-client**: the inputs and events of the main components, for example a results list that receives hotel summaries and emits "hotel selected", which the map also listens for. Spend real time on component inputs only when a component is the product or its hardest part. ## O: optimizations and deep dives The last stage picks **one or two areas** this product lives or dies by, driven by the non-functional requirements: for this app, how its landing pages reach crawlers and low-end phones quickly, or how the booking form survives a flaky network. Each of those has its own depth; this stage is about choosing and justifying them. ## How the stages fit together The frame's authors suggest roughly **10 / 20 / 10 / 20 / 40 %** of the session for the five stages, with requirements taking no more than about a tenth. Treat that as their suggestion, not a rule. They are equally clear that RADIO is **not a rigid linear order**: some products read better interface-first, and a requirement you notice while drawing the architecture can send you back to revise the data model. What matters is that requirements come first and that every stage has an artifact by the end.
- Why is a frontend round's data model not a database schema?Because the client holds a subset of server data shaped for screens, plus data that never reaches a database. A hotel's search summary carries a name, a starting price and one photo, not its whole record, while the carousel's current photo exists only in the browser. Tagging each field by origin tells you later what to fetch, what to send and what may be lost on reload.
- Must the data model be finished before you define the interface?No. The frame's authors present it as a checklist, not a linear script: some products are clearer interface-first, and a requirement noticed while drawing the architecture can send you back to revise the data model. What matters is that requirements come first and every stage has an artifact on the board by the end.
- When does the component half of the interface deserve real time?When one component is the product or its hardest part, such as a results map that must stay in step with the list, or a reusable date-range picker. Otherwise give the main components' inputs and events a line each and spend the minutes on the server-client calls and the deep dives.
- The architecture diagram shows load balancers, app servers and database replicas.
- The data model is the bookings service's database schema.
- The interface is only the HTTP endpoints; components in the browser have none.
- RADIO is a fixed sequence, so going back to an earlier stage is a mistake.
- Choosing the component framework is the first architecture decision.