← Airbnb Interview Insights

Airbnb·Backend Engineer·Onsite - System Design / Architecture·Senior

SeniorPrefer not to say
May 2026

Summary

Airbnb backend system design round, pretty brutal scope. They wanted the whole thing: search, availability, booking, ML ranking, the works. Felt like three interviews crammed into one.

Questions Asked (5)

Q1

Design the backend for Airbnb's home page, listing search, and booking system at scale. Walk through your architecture end to end.

System DesignTechnical Trade-offsData Modeling
Author's notes

I started with the search path and worked outward, which in retrospect was the right call since that's where most of the complexity lives.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying functional and non-functional requirements, then propose a high-level architecture that separates read-heavy search/browse traffic from write-heavy booking transactions. Dive into data modeling, scaling strategies, and trade-offs for each component, emphasizing availability, consistency, and latency.

Pro tip: Explicitly discuss how you would handle peak traffic (e.g., during holidays) and ensure data consistency for bookings without sacrificing availability, showing awareness of real-world constraints like CAP theorem and eventual consistency.

1. Clarify Requirements and Scope

Ask questions to understand expected scale (users, listings, bookings per second), latency requirements, consistency needs, and key features (search filters, real-time availability, payment integration).

2. High-Level Architecture

Outline main components: CDN for static assets, API gateway, microservices for search, booking, user management, and databases (SQL for transactions, NoSQL for search, cache for hot data).

3. Data Modeling and Storage

Design schemas for listings, bookings, and users; choose appropriate databases (e.g., PostgreSQL for bookings, Elasticsearch for search, Redis for caching) and discuss sharding/replication strategies.

4. Scaling and Trade-offs

Explain how to scale each service (horizontal scaling, caching, read replicas, partitioning) and discuss trade-offs between consistency, availability, and latency (e.g., using eventual consistency for search but strong consistency for bookings).

5. Failure Handling and Monitoring

Describe strategies for fault tolerance (circuit breakers, retries, idempotency), monitoring, and alerting to ensure high availability and quick recovery.

Key Points to Mention

  • Separation of read and write paths: use read replicas and caching for search/browse, while booking writes go to a transactional database with ACID guarantees.
  • Search implementation: inverted index (e.g., Elasticsearch) with geospatial queries, faceted search, and ranking algorithms.
  • Booking consistency: use distributed transactions or saga patterns to handle multi-step booking (availability check, payment, reservation) with idempotency keys.
  • Caching strategy: cache popular listings and search results with TTL and invalidation on updates; use CDN for static content.
  • Database sharding: shard by user ID or geographic region to distribute load; consider replication for read scalability and failover.
  • Handling peak traffic: auto-scaling, rate limiting, queueing for booking requests, and graceful degradation (e.g., disable non-critical features).

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Q2

How would you handle cache invalidation when listing availability changes frequently?

System DesignTechnical Trade-offs
Author's notes

This tripped me up more than I expected.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the requirements: how frequently availability changes, the acceptable staleness, and the read/write ratio. Then propose a layered caching strategy with short TTLs, event-driven invalidation, and fallback mechanisms, discussing trade-offs between consistency and latency.

Pro tip: Emphasize that cache invalidation is not just about deletion but also about updating or versioning; consider using a write-through cache with a message queue to propagate invalidations asynchronously, and always have a fallback to the source of truth to avoid stale data.

1. Clarify Requirements

Ask about the frequency of availability changes, the acceptable staleness window, read/write patterns, and consistency requirements to tailor the solution.

2. Choose Caching Strategy

Decide between TTL-based expiration, write-through/write-behind, or event-driven invalidation based on the requirements; often a combination works best.

3. Design Invalidation Mechanism

Implement a reliable invalidation system, such as publishing events to a message queue when availability changes, and have cache nodes subscribe to invalidate or update entries.

4. Handle Race Conditions and Failures

Address issues like stale reads during invalidation, network partitions, and cache stampedes; use techniques like versioning, locks, or request coalescing.

5. Monitor and Iterate

Set up metrics for cache hit rate, staleness, and invalidation latency; be prepared to adjust TTLs or invalidation strategies based on observed behavior.

Key Points to Mention

  • TTL (Time-To-Live) as a simple but potentially stale approach
  • Event-driven invalidation using pub/sub or message queues (e.g., Kafka, Redis Pub/Sub)
  • Write-through vs. write-behind caching for consistency
  • Cache stampede mitigation (e.g., locking, probabilistic early expiration)
  • Fallback to source of truth when cache is invalid or unavailable
  • Trade-offs between consistency, latency, and system complexity

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Q3

How would you integrate ML-based personalized ranking and home page recommendations into this system? Describe the online inference path.

System DesignTechnical Trade-offsA/B Testing & Experimentation
Author's notes

Talked through a feature store feeding a lightweight ranking model, pre-computed embeddings for listings, and a two-stage retrieval-then-rank setup.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the system context and requirements, then focus on the online inference path for ML-based personalized ranking and recommendations. Describe a scalable architecture that balances latency, freshness, and personalization, and discuss trade-offs and experimentation.

Pro tip: Emphasize the importance of a feature store to ensure consistency between training and serving, and discuss how you would handle cold-start users and real-time feature updates.

1. Clarify Requirements and Constraints

Ask about scale (QPS, latency SLAs), data freshness, and personalization goals. Confirm the existing system components and where ML integration is needed.

2. Design the Online Inference Path

Outline the flow: request → feature retrieval → model inference → ranking → response. Discuss using a feature store for low-latency feature access and a model server for inference.

3. Address Scalability and Latency

Explain how to scale horizontally, use caching, precompute embeddings, and optimize model inference (e.g., model quantization, batching). Mention fallback strategies for high load.

4. Handle Personalization and Freshness

Describe how to incorporate user context, real-time signals, and session data. Discuss trade-offs between precomputed and on-the-fly features.

5. Discuss Experimentation and Monitoring

Explain A/B testing framework, logging for offline evaluation, and monitoring for model drift and performance degradation.

Key Points to Mention

  • Feature store for consistent online/offline features
  • Low-latency model serving (e.g., TensorFlow Serving, TorchServe)
  • Caching strategies for embeddings and popular items
  • Handling cold-start users with fallback recommendations
  • A/B testing and interleaving for ranking evaluation
  • Monitoring and logging for model performance and drift

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Q4

How would you design the A/B testing infrastructure to safely experiment with ranking changes without degrading the booking experience?

A/B Testing & ExperimentationTechnical Trade-offs
Author's notes

Shorter discussion than I expected.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the goal: safely test ranking changes without harming booking metrics. Then walk through a layered design covering experiment assignment, guardrail metrics, gradual rollout, and monitoring, emphasizing safety and statistical rigor.

Pro tip: Emphasize guardrail metrics and automated kill switches—Airbnb cares deeply about not degrading user experience, so showing you prioritize safety over speed will set you apart.

1. Define experiment scope and metrics

Clarify what ranking changes are being tested and identify primary success metrics (e.g., bookings) and guardrail metrics (e.g., booking latency, cancellation rate, user satisfaction).

2. Design assignment and bucketing

Use a consistent hashing or user-level randomization to assign users to control/treatment groups, ensuring stable assignment and avoiding interference between experiments.

3. Implement gradual rollout and safety checks

Start with a small percentage of traffic, monitor guardrail metrics in real-time, and automatically halt the experiment if degradation is detected.

4. Ensure statistical validity and analysis

Predefine sample size, run power analysis, and use appropriate statistical tests (e.g., sequential testing) to avoid false positives while allowing early stopping.

5. Monitor, iterate, and document

Continuously monitor system health and business metrics, iterate on the design based on learnings, and document the process for reproducibility and future experiments.

Key Points to Mention

  • Guardrail metrics (e.g., booking latency, error rates, cancellation rate) to detect degradation
  • User-level randomization and consistent hashing to avoid assignment bias
  • Gradual traffic ramp-up (e.g., 1% -> 5% -> 50%) with automated kill switches
  • Statistical power analysis and sequential testing to balance speed and rigor
  • Isolation of experiments to prevent interference (e.g., using separate layers or namespaces)
  • Monitoring and alerting integration with existing observability tools

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Q5

Walk me through how you'd implement a hold or soft-lock on a listing during the booking flow to prevent double-booking.

System DesignData ModelingTechnical Trade-offs
Author's notes

This is the part I felt best about.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements: hold duration, user experience, and consistency needs. Then propose a distributed lock or reservation record with TTL, stored in a fast datastore like Redis, and discuss how to handle failures, expiry, and race conditions. Finally, cover trade-offs between strong consistency and availability, and how to scale the solution.

Pro tip: Mention that holds should be idempotent and tied to a user/session to prevent accidental double-holds, and always include a fallback mechanism like optimistic concurrency control at the database level for final booking confirmation.

1. Clarify Requirements and Constraints

Ask about expected hold duration, user experience (e.g., countdown timer), and consistency requirements (strong vs eventual). Also consider scale: number of listings, concurrent users, and geographic distribution.

2. Design the Hold Mechanism

Propose using a distributed lock or reservation record with a TTL. For example, use Redis with SET NX and EXPIRE to atomically acquire a hold, or a database row with a status and expiration timestamp. Ensure the hold is associated with a user/session ID.

3. Handle Expiry and Release

Implement automatic expiry via TTL or a background job that cleans up expired holds. Provide explicit release when the user cancels or completes booking. Ensure that expired holds are not considered valid.

4. Ensure Atomic Booking Confirmation

When the user confirms, atomically check that the hold is still valid and then create the booking. Use a transaction or compare-and-swap to avoid race conditions. If the hold expired, return an error and prompt the user to try again.

5. Discuss Trade-offs and Failure Modes

Address trade-offs: Redis is fast but may lose data on failure; database is durable but slower. Discuss handling network partitions, clock skew, and idempotency. Mention monitoring and alerting for hold contention.

Key Points to Mention

  • Use of TTL-based holds to automatically release after a timeout
  • Atomic operations (e.g., Redis SET NX, database transactions) to prevent race conditions
  • Idempotency keys to avoid duplicate holds from retries
  • Fallback to optimistic concurrency control (e.g., version numbers) at booking confirmation
  • Handling of expired holds and user experience (e.g., countdown timer, error messages)
  • Scalability considerations: sharding, replication, and geographic distribution

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.