← Datadog Interview Insights

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

Senior
May 2026

Summary

System design round at Datadog for a software engineer role. The whole thing was basically a deep dive into designing YouTube from scratch, covering everything from upload pipelines to recommendations. Pretty broad scope for a single session.

Questions Asked (4)

Q1

Design a video platform like YouTube. Walk through how you'd handle video upload, transcoding, storage, streaming, and core social features like comments, likes, and subscriptions.

System DesignTechnical Trade-offs
Author's notes

This is a monster of a question and I think I underestimated the scope at first.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale (e.g., daily uploads, concurrent viewers, global reach), then design the core pipeline: upload, transcoding, storage, and streaming. Finally, layer on social features, discussing trade-offs and data models for comments, likes, and subscriptions.

Pro tip: Emphasize observability and failure handling at each stage—Datadog values engineers who design systems that are monitorable and resilient. Also, discuss how you'd evolve the design from MVP to scale, showing pragmatism.

1. Clarify Requirements and Scale

Ask questions to understand expected scale (e.g., uploads per day, concurrent viewers, global distribution) and key features (e.g., video quality, latency, social interactions). Define functional and non-functional requirements.

2. Design Upload and Transcoding Pipeline

Outline the upload process: client uploads to object storage via pre-signed URLs, then trigger transcoding jobs (e.g., using a queue and worker fleet) to generate multiple resolutions and formats. Discuss chunked/resumable uploads and validation.

3. Design Storage and Streaming

Choose storage: object storage (e.g., S3) for raw and transcoded videos, CDN for global distribution, and metadata in a database. For streaming, use adaptive bitrate streaming (HLS/DASH) with CDN caching.

4. Design Social Features

Model comments, likes, and subscriptions in a database (e.g., SQL for transactions, NoSQL for scale). Discuss caching, fan-out strategies for subscriptions (push vs. pull), and handling high read/write volumes.

5. Discuss Trade-offs and Scalability

Highlight trade-offs: consistency vs. availability, cost vs. performance, and complexity. Explain how to scale each component (e.g., sharding, replication, CDN) and how to monitor with Datadog.

Key Points to Mention

  • Use of object storage (e.g., S3) for video storage and CDN for efficient global streaming.
  • Transcoding pipeline with message queues (e.g., Kafka, SQS) and worker pools for parallel processing.
  • Adaptive bitrate streaming (HLS/DASH) to handle varying network conditions.
  • Database choices: SQL for user/subscription data, NoSQL for comments/likes at scale, with caching (Redis) for hot data.
  • Fan-out strategies for subscriptions: push (write-heavy) vs. pull (read-heavy) and hybrid approaches.
  • Observability: metrics, logging, tracing, and alerting (e.g., Datadog) for each component.

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

Q2

How would you design the search functionality for a video platform at scale?

System DesignData Modeling
Author's notes

Jumped straight to Elasticsearch and the interviewer asked me to justify it rather than just name-drop it.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements (scale, latency, search types) and then outline a high-level architecture that separates indexing from querying. Dive into data modeling, storage choices (e.g., inverted index, distributed search engine), and scaling strategies like sharding and replication. Conclude with trade-offs and monitoring.

Pro tip: Emphasize the importance of relevance tuning and how you would measure search quality (e.g., click-through rate, NDCG) in production. Also, mention how Datadog's own monitoring tools could be used to observe search performance.

1. Clarify Requirements

Ask about scale (number of videos, queries per second), latency requirements, search types (keyword, semantic, filters), and data freshness. This ensures the design meets actual needs.

2. High-Level Architecture

Propose a system with separate indexing and query services. Use a distributed search engine like Elasticsearch or Solr for the inverted index, and a message queue for ingesting video metadata updates.

3. Data Modeling and Indexing

Define the schema for video documents (title, description, tags, transcript, etc.). Discuss tokenization, stemming, and how to handle multilingual content. Consider using embeddings for semantic search.

4. Scaling and Performance

Explain sharding and replication for horizontal scaling. Use caching (e.g., Redis) for popular queries. Discuss strategies for low-latency retrieval, such as pre-computing results or using CDNs for static assets.

5. Trade-offs and Monitoring

Discuss trade-offs between consistency and availability, cost of indexing vs. query speed, and relevance vs. latency. Outline monitoring metrics (query latency, error rates, index size) and how to use Datadog for observability.

Key Points to Mention

  • Inverted index and distributed search engines (e.g., Elasticsearch)
  • Sharding and replication for scalability and fault tolerance
  • Caching strategies for hot queries
  • Relevance ranking and tuning (e.g., TF-IDF, BM25, learning to rank)
  • Data ingestion pipeline and near-real-time indexing
  • Monitoring and observability (e.g., Datadog metrics, logs, traces)

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

Q3

Walk me through how you'd build a recommendation system for videos, from candidate generation to final ranking.

System DesignTechnical Trade-offs
Author's notes

Honestly the part I felt least prepared for.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements (scale, latency, metrics) and then describe a two-stage architecture: candidate generation (e.g., collaborative filtering, embeddings) followed by ranking (e.g., learning-to-rank with features). Emphasize trade-offs between accuracy, latency, and scalability, and how you'd evaluate and iterate.

Pro tip: At Datadog, tie the design to observability: explain how you'd monitor model performance, data drift, and system health, and how you'd use A/B testing to validate improvements.

1. Clarify Requirements

Ask about scale (users, videos, QPS), latency constraints, and success metrics (CTR, watch time). This ensures the design meets business needs.

2. High-Level Architecture

Outline a two-stage system: candidate generation to narrow millions of videos to hundreds, then ranking to order them. Mention offline/online components.

3. Candidate Generation

Describe methods like collaborative filtering, content-based, or embedding-based retrieval (e.g., two-tower models). Discuss trade-offs (e.g., recall vs. diversity).

4. Ranking

Explain using a learning-to-rank model (e.g., GBDT, neural network) with features like user history, video metadata, and context. Discuss training and serving.

5. Evaluation & Iteration

Cover offline metrics (precision@k, NDCG) and online A/B testing. Mention monitoring for drift and feedback loops.

Key Points to Mention

  • Two-stage architecture: candidate generation and ranking
  • Collaborative filtering and embedding-based retrieval (e.g., two-tower models)
  • Feature engineering: user, item, and context features
  • Trade-offs: latency vs. accuracy, diversity vs. relevance
  • Evaluation: offline metrics and online A/B testing
  • Monitoring and observability for model performance and data drift

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

Q4

How would you handle non-functional requirements like global low-latency playback, high availability, and petabyte-scale video storage?

System DesignTechnical Trade-offs
Author's notes

CDN placement and replication strategy were the core of my answer here.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the scale and constraints (e.g., number of users, regions, video sizes) and then systematically address each non-functional requirement (latency, availability, storage) with specific architectural patterns and trade-offs. Emphasize how you would measure and monitor these requirements, and how you'd iterate based on data.

Pro tip: Tie each non-functional requirement to a concrete SLO and explain how you'd instrument and alert on it, showing you think like an owner. Also, acknowledge trade-offs explicitly—e.g., global low latency often increases cost and complexity, so discuss how you'd balance them.

1. Clarify requirements and constraints

Ask questions to understand the expected scale (e.g., petabytes of video, number of concurrent viewers, geographic distribution) and the specific targets for latency and availability. This ensures your design is grounded in realistic assumptions.

2. Design for global low-latency playback

Propose a multi-region CDN strategy with edge caching and adaptive bitrate streaming. Discuss how to minimize latency through protocols like HTTP/3, QUIC, and by placing content close to users.

3. Ensure high availability

Outline redundancy at every layer: multi-AZ deployments, automatic failover, health checks, and graceful degradation. Mention the importance of defining SLOs and using chaos engineering to validate resilience.

4. Architect for petabyte-scale storage

Describe a tiered storage approach: hot storage for frequently accessed videos (e.g., SSD-backed object storage), warm/cold tiers for less accessed content (e.g., HDD or archival), and lifecycle policies to move data. Discuss erasure coding, sharding, and metadata management.

5. Discuss trade-offs and monitoring

Explicitly state trade-offs between cost, latency, and consistency. Explain how you would monitor key metrics (latency percentiles, error rates, storage growth) and use them to drive improvements.

Key Points to Mention

  • CDN and edge caching for low-latency global playback
  • Multi-region active-active or active-passive deployments for high availability
  • Object storage with tiering (e.g., S3 Intelligent-Tiering, Glacier) for petabyte scale
  • Erasure coding and replication for durability and cost efficiency
  • SLOs and monitoring (e.g., p99 latency, availability percentage)
  • Trade-offs: cost vs. latency, consistency vs. availability, complexity vs. maintainability

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