← Booking.com Interview Insights

Booking.com·Software Engineer·Onsite - System Design / Architecture·Senior

SeniorPrefer not to say
Apr 2026

Summary

System design round at Booking.com for a software engineer role. The whole thing centered on one big problem: design a logging and metrics platform that has to handle billions of events a day without slowing down the services writing to it, while still letting you query the data in real time.

Questions Asked (1)

Q1

Design a centralized logging and metrics system used by many internal services, supporting high-volume async writes, real-time queries, filtering, aggregations, and billions of events per day.

System DesignTechnical Trade-offsData Modeling
Author's notes

This is basically a full-stack systems problem and I felt it the second they finished reading it.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale (billions of events/day, real-time queries, async writes), then propose a high-level architecture with ingestion, storage, and query layers. Discuss trade-offs between components (e.g., Kafka vs. Pulsar, ClickHouse vs. Druid) and how they meet the needs for high-volume writes, real-time queries, filtering, and aggregations.

Pro tip: Emphasize the importance of a schema-on-write approach with a well-defined data model to enable efficient filtering and aggregations, and mention how you would handle backpressure and ensure exactly-once semantics in the ingestion pipeline.

1. Clarify Requirements and Scale

Ask questions to understand the volume (billions of events/day), latency requirements (real-time queries), query patterns (filtering, aggregations), and data retention. Confirm the need for high availability and durability.

2. Design High-Level Architecture

Outline the main components: ingestion (e.g., Kafka), storage (e.g., ClickHouse, Druid, or Elasticsearch), and query service. Explain how data flows from services to storage and how queries are served.

3. Deep Dive into Ingestion and Storage

Detail how to handle high-volume async writes: partitioning, batching, compression, and backpressure. Discuss storage choices: columnar stores for analytics, time-series databases, or search engines, and justify based on query needs.

4. Address Real-Time Queries and Aggregations

Explain how to support real-time queries: indexing strategies, pre-aggregation, materialized views, and caching. Discuss how to handle filtering efficiently (e.g., inverted indexes, bloom filters).

5. Discuss Trade-offs and Operational Concerns

Compare alternatives (e.g., Kafka vs. Pulsar, ClickHouse vs. Druid vs. Elasticsearch) and discuss trade-offs in consistency, latency, cost, and complexity. Mention monitoring, scaling, and failure recovery.

Key Points to Mention

  • Use of a distributed message queue (e.g., Kafka) for ingestion to decouple producers and consumers, handle backpressure, and ensure durability.
  • Choice of a columnar or time-series database (e.g., ClickHouse, Druid) for efficient storage and fast aggregations on large datasets.
  • Data modeling: schema design with appropriate partitioning and sorting keys to optimize filtering and aggregation queries.
  • Real-time query capabilities: use of pre-aggregation, materialized views, and caching to reduce query latency.
  • Scalability and fault tolerance: horizontal scaling of ingestion and storage layers, replication, and handling of node failures.
  • Trade-offs: consistency vs. availability, latency vs. cost, and complexity of maintaining multiple components.

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