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

Senior

Jun 2026

Summary

System design round at Booking.com for a software engineer role. The whole thing was one big design question about building a logging and metrics platform at scale, and it went pretty deep into every layer of the stack.

Questions Asked (1)

Design a logging and metrics system that handles billions of events per day from many internal services. Cover the full pipeline: how services emit events, how data gets ingested and buffered, how it's processed and aggregated, how it's stored across hot and cold tiers, and how the query layer serves real-time dashboards and alerts. Also address the tension between async fire-and-forget writes and the need for low-latency reads.

System DesignTechnical Trade-offsData Modeling

Author's notes

This was a lot to hold in your head at once.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale, then walk through the pipeline stage by stage: ingestion, buffering, processing, storage, and query. Emphasize trade-offs, especially how you decouple writes from reads to handle the async vs. low-latency tension.

Pro tip: Propose a dual-path architecture: a fast path for real-time metrics (e.g., stream processing with approximate aggregations) and a batch path for accurate historical data, and discuss how to reconcile them.

1. Clarify Requirements and Scale

Ask about event volume, latency requirements, data retention, query patterns, and consistency needs. Establish assumptions like billions of events/day, sub-second dashboard latency, and 1-year retention.

2. Design Ingestion and Buffering

Services emit events asynchronously via lightweight agents (e.g., Fluentd, Filebeat) to a durable, scalable buffer like Kafka. Discuss partitioning, replication, and backpressure handling.

3. Design Processing and Aggregation

Use stream processing (e.g., Flink, Spark Streaming) for real-time aggregations and a batch layer (e.g., Spark) for accurate rollups. Address windowing, late data, and exactly-once semantics.

4. Design Storage Tiers

Store hot data in a time-series DB or search engine (e.g., Elasticsearch, Druid) for fast queries, and cold data in cheap object storage (e.g., S3) with columnar format (Parquet). Discuss tiering and retention policies.

5. Design Query and Alerting Layer

Provide a query service that routes to hot or cold storage, caches frequent queries, and supports real-time dashboards and alerting. Discuss push vs. pull for alerts and how to handle high cardinality.

Key Points to Mention

Decoupling writes and reads via a message queue (e.g., Kafka) to absorb spikes and enable async processing.
Use of stream processing for real-time aggregations and batch processing for accuracy, with a lambda or kappa architecture.
Storage tiering: hot tier (e.g., Druid/Elasticsearch) for low-latency queries, cold tier (e.g., S3+Parquet) for cost-effective long-term storage.
Query layer optimizations: caching, pre-aggregation, and routing to appropriate tier based on time range.
Handling high cardinality and ensuring scalability via partitioning and sharding.
Trade-offs: consistency vs. latency, cost vs. performance, and complexity of maintaining dual pipelines.

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