Design a travel search system (Expedia): the system design interview walkthrough
The request to design a travel search system — flights or hotels, Expedia-style — looks like a search box over a big table. The twist that makes it an interview problem is that you do not own the inventory. The prices and availability live behind dozens of external suppliers — global distribution systems, airlines, hotel channel managers — each slow, each occasionally down, each returning data in its own format, and all of it perishable: the fare you showed a user thirty seconds ago may already be gone. So the real design is an aggregator that fans one search out to many unreliable sources under a strict time budget, stitches their partial answers together, caches results that expire almost immediately, and still charges the right price when the user finally clicks book. This is one of the harder system design interview prompts because the naive "query the database" answer ignores that there is no single database — the data is scattered, slow, and stale by the time you read it.
The round turns on three decisions. First, supplier fan-out — how you scatter a search across many slow, flaky providers, bound the wait with a deadline, and return the partial results you have rather than hanging on the slowest. Second, caching the uncacheable — how you cache prices and availability that change by the minute, and how you handle the gap between the price a user saw and the price that is real at checkout. Third, ranking and consistent booking — how you rank the merged set and complete a booking against external inventory without double-selling a room. This walkthrough follows the path a strong candidate draws on the whiteboard — requirements, estimate, API and data model, high-level design, then the deep dives — and at each step it names the follow-up the interviewer uses to tell a memorised answer from an engineer who understands the tradeoff.
How the travel search round is actually run
A travel search round runs about 60 minutes on a shared canvas — you draw the boxes and arrows while you talk, and the interviewer interrupts. It is a favourite search-and-discovery problem because the one-line brief hides a hard distributed-systems truth: the system is a front end over a fleet of external dependencies it does not control, so it is really about aggregation under uncertainty — slow suppliers, flaky connections, perishable data — rather than a clever query. Get the scatter-gather, the perishable caching and the re-price-at-book clean and you have shown you understand a class of systems (metasearch, aggregators, price-comparison) in one problem.
The interviewer rarely lets "search the inventory and sort by price" stand. "There is no single inventory — the prices live behind thirty external suppliers, one of which is timing out right now and another whose fares went stale ten seconds ago. What do you show the user, and what do they actually pay?" That question — aggregating slow, flaky, perishable sources and still being correct at checkout — is the one a copied answer can never rehearse, and the one this round is really testing.
The rounds here are modelled on how the loop runs, not scraped from any candidate's recall. What matters for prep is the shape: a blank canvas, a clock, and a follow-up after every decision you make.
The five-step framework for any HLD round
Every high-level design answer fits the same spine. Say it out loud at the start so the interviewer knows you have a plan, then walk it:
- Clarify requirements — what is searched, that supplier data is external/slow/perishable, and the latency and correctness targets.
- Estimate — searches per second, suppliers per search, and the read/write skew, to justify the aggregator shape.
- High-level design — the boxes and arrows: client, search service, supplier connectors, cache, ranking, booking.
- Deep dive — the two or three decisions that actually decide this system.
- Follow-ups — bottlenecks, failure modes, and what you would change at ten times the scale.
What the debrief measures
The score is not "right or wrong design." A good HLD debrief reads on four dimensions, and every move below maps to one: problem solving (did you bound the supplier fan-out with a deadline and return partial results instead of hanging), communication (did you explain why travel prices are perishable and must be re-validated at booking, in a sentence), technical execution (scatter-gather with timeouts and circuit breakers, short-TTL caching with popular-route warming, re-price at checkout, consistent booking against external inventory), and time management (did you spend your 60 minutes on aggregation, caching and booking, not on the filters UI). Reading a walkthrough teaches the design; it does not teach you to deliver it on the clock while someone pushes back.
Step 1 — Requirements: what a travel search system must do
Spend the first few minutes here. Jumping to boxes before you have scoped the problem is the fastest way to design the wrong system.
| Type | Requirement |
|---|---|
| Functional | Search flights/hotels by origin, destination, dates and filters; aggregate availability and pricing from many external suppliers; rank the merged results; show details; let a user book, taking payment and confirming inventory with the supplier. |
| Functional (optional) | Multi-leg/connecting itineraries, flexible-date search, price alerts, loyalty, cancellations — call these out, then scope most of them for later. |
| Non-functional | Read-heavy (searches ≫ bookings); tolerable search latency measured in seconds, not milliseconds, because suppliers are slow; supplier data is external, slow and flaky — the system must degrade gracefully (partial results); prices/availability are perishable and must be correct at booking; bookings must be consistent (no double-sell); highly available and scalable. |
The sentence that earns points: "We don't own the inventory — it lives behind many slow, flaky, perishable external suppliers — so the design is an aggregator: scatter-gather each search under a deadline, cache the perishable results briefly, and re-validate the price and availability at booking, because what the user saw is only indicative." Say that and you have framed the entire design before drawing a box.
Step 2 — Capacity estimation (back of the envelope)
Estimation here is about proving one thing: the hard axis is aggregating slow external suppliers cheaply, which makes caching and fan-out control the whole design.
| Quantity | Assumption | Result |
|---|---|---|
| Searches | millions/day | ~thousands/sec at peak → each would fan out to dozens of suppliers if uncached |
| Suppliers per search | dozens of providers | without a cache, one search = dozens of slow external calls → suppliers get hammered |
| Supplier latency | hundreds of ms to seconds, variable | the search is as slow as your deadline, not your fastest supplier → bound it |
| Read:write | searches ≫ bookings | ~1000:1+ → optimise the read/search path; booking is rare but must be correct |
| Cache | short TTL (seconds–minutes) | a high cache-hit ratio is what keeps supplier load (and cost) survivable |
Two conclusions fall out, and you should say both out loud. First, caching is load-bearing, not an optimisation — you cannot call dozens of slow external suppliers on every one of thousands of searches a second, so a short-TTL cache absorbs the vast majority of searches and only misses fan out to suppliers. Second, the supplier fan-out must be bounded — suppliers are slow and flaky, so a search runs under a deadline and returns whatever has come back by then, because waiting on the slowest supplier makes every search as slow as the worst provider. You have now pointed the interview at caching and scatter-gather — the real deep dives — before anyone asked.
Step 3 — API and data model
The interface is a search, a details lookup, and a booking; the design lives in how the search aggregates suppliers and how the booking re-validates them.
| Call | Operation |
|---|---|
search(origin, dest, dates, filters) → results[]
|
serve from cache if warm; else scatter-gather live suppliers under a deadline, normalise, merge, rank |
getDetails(result_id) → offer
|
fetch the full, current offer (often a live supplier call) for a chosen result |
price(offer) → confirmed_price
|
re-validate the price and availability with the supplier at checkout (the look-to-book step) |
book(offer, payment) → confirmation
|
hold inventory with the supplier, take payment, confirm — idempotently |
The data model spans normalised search results, the cache, and the booking:
| Entity | Notes |
|---|---|
supplier_offer |
a normalised result from one supplier: route/room, price, availability, fare rules, supplier_id, valid_until. Heterogeneous raw responses are mapped into this shape. |
search_cache |
keyed by the search (route + dates + filters), a short-TTL set of offers; expires fast because prices are perishable. |
booking |
offer, user, payment, status (held/confirmed/failed), an idempotency key, and the supplier confirmation reference. |
popular_route |
precomputed/warmed cache entries for hot routes and dates, refreshed on a schedule. |
Step 4 — High-level design: the aggregator
Now the boxes. A travel search system is a read-heavy aggregator fronted by caches, with a separate, careful booking path:
- Client → search service: receives the query and first checks the cache; on a hit it returns instantly, on a miss it fans out.
- Scatter-gather → supplier connectors: on a miss, the search service calls many supplier connectors in parallel (each wrapping one external provider's API) under a deadline, collecting whatever returns in time.
- Normalise + aggregate + rank: heterogeneous supplier responses are mapped to a common offer shape, de-duplicated, merged, cached with a short TTL, and ranked (price, duration, stops, relevance).
- Cache + popular-route warming: a short-TTL result cache absorbs most searches, and a background job pre-warms popular routes/dates so hot searches rarely hit suppliers.
- Booking service (the careful path): when a user books, the system re-prices (re-validates with the supplier), holds inventory, takes payment, and confirms — idempotently, because external calls and retries must not double-book.
Say explicitly that this is an aggregator over external suppliers, not a query over owned inventory — the cache and the bounded fan-out carry the read load, and the booking path re-validates because the cached price is only indicative. Naming the scatter-gather-under-deadline and the re-price-at-book unprompted is a signal the interviewer is listening for.
Deep dive: supplier fan-out and aggregation
This is the decision that decides the round, because the suppliers — not your own servers — are the thing you cannot control. A search has to query many of them, and they are slow, flaky, and inconsistent.
Scatter-gather under a deadline. On a cache miss, the search service calls the relevant supplier connectors in parallel and collects responses until a deadline (say a second or two). It does not wait for the slowest — when the clock runs out, it returns the partial results it has, because one timing-out supplier must not make every search hang. The connectors normalise each provider's idiosyncratic response into the common offer shape, and the aggregator de-duplicates (the same hotel from two channels) and merges.
Protecting against flaky suppliers. A supplier that is slow or failing cannot be allowed to drag down the whole system, so each connector wraps its provider in a circuit breaker (stop calling a provider that is erroring, fail fast, retry later) and sensible timeouts and retries. The system is explicitly best-effort on completeness: it is better to show the user results from twenty-eight of thirty suppliers immediately than to show nothing while waiting on the two that are down. Saying "I return partial results on a deadline and circuit-break flaky suppliers" is the senior move.
"One supplier is timing out and another is throwing errors mid-search — what does the user see?" A full result set minus those two: the search scatter-gathers under a deadline and returns partial results when the clock runs out, and a circuit breaker stops calling the erroring supplier so it fails fast instead of dragging the search down. Name the deadline, partial results, and the circuit breaker.
Deep dive: caching perishable price and availability
This is the decision most candidates under-think, because travel data breaks the usual caching rules: the thing you most want to cache is the thing that changes the fastest.
Cache with short TTLs and warm the hot routes. You cannot call dozens of suppliers on every search, so you cache search results — but prices and availability are perishable, so the cache entries get short TTLs (seconds to a few minutes) and expire quickly rather than serving a stale fare for an hour. A background job pre-warms popular routes and dates (a Friday New York-to-London search is predictable), so the hottest searches are almost always cache hits. Only current and near-future availability matters, so a TTL/LRU store (Redis-style) is ideal — old inventory ages out automatically.
The look-to-book gap. Even with short TTLs, the price a user saw can be gone by the time they book — the classic look-to-book problem. So the cached price is treated as indicative only: at checkout the booking path re-prices, calling the supplier live to confirm the current price and availability, and if it changed the user is shown the new price before paying. The cache is the source of truth for browsing; the supplier is the source of truth for booking. Naming that split — cache to show, re-validate to sell — is exactly what the interviewer wants.
"You cached a $300 fare; by checkout the airline's price is $340. What happens?" The cached price was only indicative — at checkout the booking path re-prices live with the supplier and, if it changed, shows the new price before the user pays. You cache aggressively with short TTLs and warm popular routes to survive the search load, but you never book on a cached price. Name short-TTL caching, popular-route warming, and re-price-at-book.
System Design
HLD · Search & discovery · 60 min
Design a travel search system out loud, with follow-ups
Deep dive: ranking and consistent booking
This is the decision that closes the loop — turning a merged pile of offers into an ordered list, and turning a chosen offer into a confirmed booking without double-selling.
Ranking the merged set. Once the partial supplier responses are normalised and de-duplicated, you rank them by what travellers care about — price, duration, number of stops, supplier reliability, and personalised relevance — and return the top results, with the usual filters and sorts on top. For flights, constructing multi-leg itineraries from individual segments adds a combinatorial step, which is why hot routes are precomputed.
Booking without double-selling. Booking is the rare write, and it must be consistent against inventory you don't fully own. The flow is re-price → hold → pay → confirm: re-validate with the supplier, place a short hold on the inventory, take payment, and confirm — all keyed by an idempotency key so a retry or a network blip cannot create two bookings. Because the steps span your system, the payment provider, and an external supplier, you treat it as a saga with compensations (release the hold and refund if confirmation fails). Hotels even allow deliberate overbooking (selling slightly more than capacity, anticipating cancellations), and the supplier's database — not your cache — is the source of truth that is re-checked before the sale is final.
"Two people book the last seat at the same moment — how do you not sell it twice?" Booking re-prices and places a hold on the supplier's inventory under an idempotency key before taking payment; the supplier's store (not the cache) is the source of truth and rejects the second hold, and the whole flow is a saga that releases the hold and refunds on failure. Name re-price→hold→confirm, idempotency, and the supplier as source of truth.
System Design
HLD · Search & discovery · 60 min
Defend aggregation, caching and booking out loud
The follow-ups that decide the travel search round
Scan the probes from each deep dive and they rhyme. Master these five and you are ready for a version of the question that is not drawn exactly like this one.
- "A supplier times out mid-search — what does the user see?" → A partial result set: scatter-gather under a deadline returns what came back, and a circuit breaker fails the flaky supplier fast. (problem solving)
- "Thousands of searches a second, dozens of slow suppliers each — how does it not melt?" → Short-TTL caching plus popular-route warming absorbs most searches; only misses fan out to suppliers. (technical execution)
- "The cached price is stale at checkout — what does the user pay?" → The current price: the cached price is indicative, and the booking path re-prices live with the supplier before payment. (communication)
- "Two users book the last room at once — how do you not double-sell?" → Re-price → hold on the supplier's inventory (the source of truth) under an idempotency key → confirm, as a saga with compensation. (problem solving)
- "What's the real bottleneck?" → Not your servers — the slow, flaky external suppliers; the design lives in the cache hit ratio and the bounded fan-out. (technical execution)
Each maps to a debrief dimension. Reading this list teaches you the answers; it does not teach you to deliver them while someone interrupts — that only comes from saying them out loud.
How to prepare: a one-week plan
You do not need fifty systems. You need this one cold and the framework automatic, so the next "design X" is just new nouns in the same five steps.
- Days 1–2: Learn the five-step framework until it is reflex. Do the travel search system end to end on paper — requirements, estimate, data model, the client → search service → supplier connectors → cache → ranking → booking aggregator.
- Days 3–4: Drill supplier fan-out: scatter-gather under a deadline, partial results, normalisation, circuit breakers and timeouts. Say each tradeoff in one sentence.
- Days 5–6: Own caching and booking — short-TTL perishable caching, popular-route warming, the look-to-book re-price, and consistent booking (hold/confirm, idempotency, saga, overbooking). Answer each of the five follow-ups out loud.
- Day 7: A full timed 60-minute round, narrating the whole way, with someone (or something) interrupting. This is the rep that counts.
This post is the deep walkthrough behind one row of the broader Top 25 system design interview questions — once the aggregator design is automatic, the same spine carries the rest of the list.
Frequently asked questions
How do I design a travel search system step by step?
Follow the five-step HLD framework. Clarify requirements (search flights/hotels, aggregate availability and pricing from many external suppliers, rank, and book — read-heavy, supplier data external/slow/flaky/perishable, correct at booking); estimate to show the hard axis is aggregating slow suppliers cheaply, which makes caching and bounded fan-out central; define the search/price/book API and the normalised supplier_offer, cache and booking model; draw the aggregator (client → search service → cache → scatter-gather supplier connectors → normalise/merge/rank, plus a booking path); then deep-dive the three decisions that matter — supplier fan-out with scatter-gather and deadlines, caching perishable price/availability with re-price at booking, and ranking with consistent booking.
How does a travel search handle slow or failing suppliers?
With a bounded scatter-gather. On a cache miss the search service calls the relevant supplier connectors in parallel and collects responses only until a deadline — a second or two — then returns whatever arrived, because waiting on the slowest supplier would make every search as slow as the worst provider. Each connector wraps its supplier in a circuit breaker that stops calling a provider that is erroring (failing fast instead of hanging) plus sensible timeouts and retries, and the aggregator normalises the heterogeneous responses into a common shape and de-duplicates them. The system is explicitly best-effort on completeness: showing results from twenty-eight of thirty suppliers immediately beats showing nothing while two are down.
Why is caching so important in a travel search system, and what's tricky about it?
Because you cannot call dozens of slow external suppliers on every one of thousands of searches a second — a short-TTL result cache absorbs the vast majority of searches, and only cache misses fan out to suppliers, so the cache hit ratio is what keeps supplier load and cost survivable. The tricky part is that the data is perishable: prices and availability change by the minute, so cache entries get very short TTLs and expire quickly rather than serving a stale fare, and a background job pre-warms popular routes and dates so the hottest searches are almost always hits. The deeper subtlety is the look-to-book gap — the price a user saw can be gone at checkout — which is why the cached price is only indicative and the booking path re-validates live.
What is the look-to-book problem?
It is the gap between when a user looks at a price and when they book it. Travel prices and availability are perishable and change constantly, so a fare you displayed from cache (or even fetched seconds ago) may no longer be valid by the time the user clicks book. If you charged the cached price blindly you would sometimes sell at a price the supplier no longer offers, or sell inventory that is gone. The fix is to treat the displayed price as indicative only and re-price at checkout: the booking path calls the supplier live to confirm the current price and availability, shows the user any change before they pay, and only then holds and confirms. The cache is the source of truth for browsing; the supplier is the source of truth for booking.
How do you prevent double-selling the same room or seat?
By making booking a consistent, idempotent flow against the supplier's inventory, which is the real source of truth — not your cache. The sequence is re-price, then place a short hold on the supplier's inventory, then take payment, then confirm, all keyed by an idempotency key so a retry or network blip cannot create two bookings. Because the steps span your service, a payment provider, and an external supplier, you run it as a saga with compensations — release the hold and refund if a later step fails. The supplier's database rejects a second hold on the last unit, and some domains (hotels) even allow deliberate overbooking to a small percentage, anticipating cancellations, with the database re-checked before the sale is final.
How do I practise a system design interview out loud?
Reading a walkthrough is not the same as defending a design while someone interrupts. On Zynter, the HLD track runs live voice rounds modelled on how real system design loops run — you talk through a shared design on the canvas, and a voice interviewer pushes with the follow-ups above one at a time, then gives you a debrief on problem solving, communication, technical execution, and time management. The score is a practice signal, not a hiring decision.
Practise it on Zynter
You can draw a search box. The round is won on scatter-gather, perishable caching and re-price-at-book.
Pick the Travel Search round, draw the aggregator on the canvas, and defend it out loud to a voice interviewer that keeps asking "what does the user see when a supplier times out?" and "what do they pay when the cached fare is stale?" — then read the debrief. Zynter.ai is on-demand mock interviews modelled on real company loops, with 150+ rounds across 20 companies including the HLD system design track (Sep 2026).
Practise the Travel Search round →
Browse all interview tracks




Top comments (0)