System Design for Booking.com SD1

Distinguish functional requirements from non-functional requirements in an interview prompt.

Ask targeted clarification questions that narrow a backend system-design problem.

Define measurable scale, latency, availability, and consistency requirements for a proposed system.

Estimate peak request rate, storage growth, and bandwidth from stated assumptions.

Draw a high-level request flow from client to storage and external dependencies.

Present assumptions and design decisions in a clear interview narrative.

Design REST API endpoints for searching properties and creating reservations.

Implement a Spring Boot reservation controller that enforces request validation and returns a consistent error schema.

Compare SQL and NoSQL storage against explicit access patterns and consistency needs.

Create a relational data model for properties, rooms, availability, users, and reservations.

Choose primary keys and indexes for common booking queries.

Design cursor-pagination parameters and an opaque continuation token for a search API.

Construct a database seek query that preserves stable ordering across result pages.

Identify the first bottleneck in a simple single-server architecture.

Compare vertical scaling with horizontal scaling for a backend service.

Explain how a load balancer distributes traffic and detects unhealthy instances.

Design a stateless service that can run safely on multiple instances.

Explain how connection pooling affects application and database capacity.

Estimate the number of service instances required for a stated traffic load.

Design a read-replica strategy and account for replication lag on correctness-sensitive reads.

Select a partition key for booking data and predict hotspots and cross-partition queries.

Apply the cache-aside pattern to a property-details read path.

Choose cache keys, expiration times, and eviction behavior for booking data.

Select an invalidation strategy based on acceptable data staleness.

Prevent cache stampedes for a frequently requested destination.

Distinguish database indexing from full-text search-engine indexing.

Design a denormalized accommodation search document and identify fields that must be revalidated before booking.

Demonstrate how concurrent requests can cause a double booking.

Use a database transaction to preserve a reservation invariant.

Compare optimistic and pessimistic locking for room inventory updates.

Select an appropriate transaction isolation level for an inventory operation.

Design an expiring inventory hold for a checkout flow.

Design an idempotency-key flow that returns the same result for repeated reservation requests.

Prevent concurrent requests sharing an idempotency key from creating multiple reservations.

Decide whether a workflow step should be synchronous or asynchronous.

Explain the difference between a work queue and publish-subscribe messaging.

Compare at-most-once, at-least-once, and effectively-once processing.

Design an idempotent consumer for duplicated reservation events.

Use the transactional outbox pattern to avoid losing reservation events between a database and a message broker.

Design bounded retries with exponential backoff and jitter for transient message failures.

Design dead-letter routing and redrive handling for poison messages.

Design an event-driven confirmation and notification flow after a reservation.

Identify single points of failure in a backend architecture diagram.

Set timeouts and bounded retries for a downstream service call.

Analyze how retries across a dependency chain can amplify load and cause cascading failure.

Apply a circuit breaker to isolate a failing dependency.

Design graceful degradation when search, recommendations, or notifications are unavailable.

Define recovery-time and recovery-point objectives and use them to design backup and restore procedures for reservation data.

Choose service-level indicators for search and reservation paths.

Define a service-level objective from a stated user expectation.

Use metrics, structured logs, and traces to investigate a slow request.

Design an alert that detects user-impacting reservation failures.

Design a token-based authentication flow for a booking API.

Enforce role-based authorization rules across booking API endpoints.

Protect personal data and sensitive credentials across storage, logs, and network calls.

Apply rate limiting to reduce abuse without blocking normal users.

Produce a high-level design for an accommodation search service.

Design a read path that combines property data, availability, and current pricing.

Design a reservation workflow that remains correct under concurrent demand.

Define the boundary and failure-handling responsibilities between a reservation service and an external payment provider.

Construct a reservation state machine covering success, payment timeout, cancellation, and refund scenarios.

Evolve a small booking architecture to handle a tenfold traffic increase.

Lead the opening phase of a system-design interview without prematurely choosing technologies.

Defend a storage choice using access patterns, scale, and consistency requirements.

Revise a design when an interviewer introduces a regional outage.

Revise a design when an interviewer requires fresher availability data.

Compare two viable architectures and state the trade-off that determines the choice.

Critique an architecture for bottlenecks, failure modes, and unnecessary complexity.

Complete a timed SDE1 booking-system design and summarize its key decisions.