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

SeniorPrefer not to say

Jun 2026

Summary

Meta SWE interview that was supposed to be a coding round but turned into a full system design deep-dive. The question was dense and covered a lot of ground, from ingestion pipelines to ML classification to storage choices to APIs to experimentation hooks. Felt underprepared for the breadth of it.

Questions Asked (1)

Design a high-throughput content processing service for a large-scale media platform that can ingest tens of millions of items per day, handle bursty traffic, apply ML classification and rule-based filtering in a near-real-time pipeline with priority queues and backpressure, choose appropriate storage for media and metadata, expose APIs for upload, review, and appeals, support A/B testing and offline evaluation, and ensure scalability, fault tolerance, and cost efficiency. Provide a diagram and justify your trade-offs.

System DesignTechnical Trade-offsA/B Testing & Experimentation

Author's notes

I went in expecting a coding question so the pivot threw me for a minute.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale, then sketch a high-level architecture that separates ingestion, processing, storage, and serving layers. Dive into key components like priority queues, backpressure, ML pipeline, storage choices, and APIs, justifying trade-offs for scalability, fault tolerance, and cost. Conclude with A/B testing and offline evaluation mechanisms.

Pro tip: Emphasize how you handle bursty traffic with backpressure and priority queues, and how you decouple components for fault tolerance and cost efficiency. Show awareness of Meta's scale and the need for near-real-time processing with ML.

1. Clarify Requirements and Scale

Ask questions to understand throughput (tens of millions/day), latency (near-real-time), priority levels, and cost constraints. Confirm the need for A/B testing and offline evaluation.

2. High-Level Architecture

Sketch a diagram with ingestion (API gateway, load balancer), message queue (Kafka), processing workers (ML and rules), storage (media in blob store, metadata in NoSQL), and serving APIs. Highlight decoupling for scalability.

3. Deep Dive into Critical Components

Explain priority queues (multiple Kafka topics), backpressure (consumer lag monitoring, rate limiting), ML pipeline (batch/stream processing), and storage choices (S3 for media, Cassandra for metadata).

4. Address Scalability, Fault Tolerance, and Cost

Discuss horizontal scaling, replication, partitioning, and failure recovery. Justify cost trade-offs (e.g., spot instances for batch, tiered storage).

5. A/B Testing and Offline Evaluation

Describe how to integrate experimentation (feature flags, shadow mode) and offline evaluation (replay logs, metrics) to improve ML models and rules.

Key Points to Mention

Use Kafka with multiple topics for priority queues and backpressure via consumer lag monitoring.
Store media in object storage (e.g., S3) and metadata in a scalable NoSQL database (e.g., Cassandra) with appropriate indexing.
Implement ML classification as a separate service with model versioning and canary deployments.
Design APIs for upload, review, and appeals with idempotency and rate limiting.
Ensure fault tolerance through replication, retries, and dead-letter queues.
Support A/B testing by routing a percentage of traffic to experimental pipelines and logging outcomes for offline analysis.

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