← Expedia Interview InsightsSoftware Engineer

Expedia·Software Engineer·Onsite - System Design / Architecture·Senior

SeniorPrefer not to say
May 2026

Summary

System design round at Expedia focused entirely on building a disaster notification system for a vacation rental platform. Pretty deep dive, lots of back-and-forth on geospatial indexing and how to handle scale.

Questions Asked (3)

Q1

Design a natural disaster notification system for a vacation rental platform. Given a disaster event with affected geographic regions, how do you efficiently identify all impacted properties, orders, hosts, and guests, and notify them within an acceptable time window?

System DesignData ModelingAPI & Integrations
Author's notes

I jumped straight into the notification pipeline and the interviewer had to pull me back to talk about how I'd even find the affected properties in the first place.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements: scale, latency, and accuracy needs. Then design a geospatial indexing strategy to efficiently map affected regions to properties, and outline a scalable notification pipeline with prioritization and fallback mechanisms.

Pro tip: Mention the importance of idempotency and deduplication in notifications to avoid alert fatigue, and consider using a multi-tiered notification system (e.g., push, SMS, email) with escalation based on urgency.

1. Clarify Requirements

Ask about scale (number of properties, users), latency requirements (acceptable time window), and accuracy (false positives/negatives).

2. Data Modeling & Geospatial Indexing

Design a data model that stores property locations and disaster regions. Use geospatial indexes (e.g., geohash, R-tree) to quickly query properties within affected areas.

3. Efficient Identification of Impacted Entities

Given a disaster event, query the geospatial index to find impacted properties. Then join with orders, hosts, and guests using precomputed mappings or database queries.

4. Notification Pipeline

Design a scalable, asynchronous notification system using message queues. Prioritize based on severity and user preferences. Implement retries and fallbacks.

5. Monitoring & Feedback

Include monitoring for delivery success and latency. Provide a feedback loop to improve accuracy and reduce false alerts.

Key Points to Mention

  • Geospatial indexing techniques (e.g., geohash, R-tree, Quadtree) for efficient region queries
  • Scalability considerations: sharding, partitioning, and caching for high-volume queries
  • Asynchronous processing with message queues (e.g., Kafka, RabbitMQ) to handle notification bursts
  • Idempotency and deduplication to prevent duplicate notifications
  • Multi-channel notification (push, SMS, email) with user preferences and fallback
  • Monitoring and alerting for system health and delivery metrics

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

Q2

How would you model and index property location data to support fast geospatial queries at scale, and what are the tradeoffs between approaches like R-tree, S2, and geohash?

Data ModelingAlgorithms & Data StructuresTechnical Trade-offs
Author's notes

Knew geohash at a surface level but got exposed pretty fast when asked about precision levels and how cell size affects false positives in range queries.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the query patterns and scale requirements, then propose a hybrid data model that combines a spatial index with a primary store. Compare R-tree, S2, and geohash on dimensions like query types, performance, and operational complexity, and recommend an approach with justification.

Pro tip: Mention that geohash and S2 are hierarchical and can be used as a coarse filter before exact distance calculations, while R-tree is better for dynamic updates but can suffer from write amplification. Also, highlight the importance of considering the read/write ratio and latency requirements.

1. Clarify Requirements

Ask about query types (radius, bounding box, nearest neighbor), expected scale (data volume, QPS), and latency/consistency requirements.

2. Propose Data Model

Suggest storing properties with lat/long and a spatial index. Consider using a primary database (e.g., PostgreSQL with PostGIS) and a secondary index like Elasticsearch or a custom index.

3. Compare Indexing Approaches

Discuss R-tree (good for dynamic data, used in PostGIS), S2 (hierarchical, good for complex regions and global scale), and geohash (simple, string-based, good for caching and sharding).

4. Discuss Tradeoffs

Cover tradeoffs: R-tree write performance vs. query performance; S2 flexibility vs. complexity; geohash simplicity vs. precision issues at boundaries.

5. Recommend and Justify

Based on requirements, recommend a hybrid approach (e.g., geohash for sharding + R-tree for indexing) and explain how it meets scale and latency needs.

Key Points to Mention

  • Geohash: encodes lat/long into a string, supports prefix queries, but has boundary issues and precision limitations.
  • S2: maps sphere to cells, hierarchical, supports complex regions, used by Google, but more complex to implement.
  • R-tree: balanced tree for spatial objects, good for dynamic updates, used in PostGIS, but can have high write overhead.
  • Hybrid approaches: combine geohash for sharding and R-tree for indexing, or use S2 for global scale.
  • Considerations: read/write ratio, latency, consistency, and operational complexity.
  • Real-world example: Expedia might use geohash for sharding property data across regions and R-tree for local queries.

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

Q3

How do you design the system to handle many concurrent disaster events without degrading notification latency or overwhelming downstream services?

System DesignTechnical Trade-offsAdaptability & Ambiguity
Author's notes

This came near the end and I was running low on steam.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and constraints (e.g., event types, scale, latency SLOs, downstream dependencies). Then propose a scalable, decoupled architecture using event-driven patterns, partitioning, and backpressure, and discuss trade-offs between consistency, latency, and cost. Finally, highlight monitoring, testing, and failure handling to ensure resilience.

Pro tip: Emphasize the importance of defining clear SLOs and using load shedding with graceful degradation to protect downstream services, rather than trying to handle every event at full fidelity. This shows maturity in balancing business needs with system reliability.

1. Clarify Requirements and Constraints

Ask about the scale (events per second), types of disasters, latency SLOs, and downstream service capacities. Identify critical vs. non-critical notifications and any regulatory requirements.

2. Design a Decoupled, Scalable Architecture

Propose an event-driven pipeline with message queues (e.g., Kafka) to buffer and distribute events. Use partitioning by disaster ID or region to parallelize processing and ensure ordering where needed.

3. Implement Backpressure and Load Shedding

Introduce rate limiting, circuit breakers, and queue depth monitoring to prevent overwhelming downstream services. Define policies for dropping or delaying low-priority notifications during spikes.

4. Optimize for Latency and Throughput

Use asynchronous processing, batch notifications where possible, and cache frequent data. Consider geo-distributed deployments to reduce network latency and ensure high availability.

5. Ensure Observability and Resilience

Set up end-to-end monitoring, tracing, and alerting on latency and error rates. Plan for graceful degradation, retries with exponential backoff, and chaos testing to validate under load.

Key Points to Mention

  • Event-driven architecture with message queues (e.g., Kafka, SQS) for decoupling and buffering
  • Partitioning and sharding to scale horizontally and maintain ordering per disaster event
  • Backpressure mechanisms: rate limiting, circuit breakers, and queue depth-based load shedding
  • Prioritization of notifications (e.g., critical alerts vs. informational updates) and graceful degradation
  • Latency optimization: asynchronous processing, batching, caching, and geo-distribution
  • Observability: metrics, tracing, and alerting on SLOs; chaos engineering for resilience

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