Openai·Software Engineer·Onsite - System Design / Architecture·Staff

StaffPrefer not to say

Jul 2026

Summary

System design round at OpenAI, one big sprawling question about notification infrastructure. The scope was genuinely intimidating and I don't think I covered everything they wanted.

Questions Asked (1)

Design a real-time notification system that supports push, email, SMS, and in-app channels at massive scale (100M+ users). Walk through event ingestion, how you'd abstract across channels, user preferences and opt-outs, deduplication, retry logic with a dead-letter queue, cross-channel fallback, delivery SLAs, fan-out architecture, your data model, gradual rollout and A/B testing hooks, observability, and abuse prevention.

System DesignData ModelingA/B Testing & Experimentation

Author's notes

This was basically one question that kept expanding.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale, then walk through the end-to-end flow from event ingestion to delivery, emphasizing decoupling via queues and abstraction layers. Structure your answer around the major components (ingestion, channel abstraction, preferences, dedup, retry/DLQ, fallback, fan-out, data model, rollout, observability, abuse prevention) and discuss trade-offs at each step. Conclude by summarizing how the design meets SLAs and scales to 100M+ users.

Pro tip: Proactively discuss trade-offs (e.g., consistency vs. latency, cost vs. reliability) and how you would measure success with SLAs and observability; this shows senior-level thinking. Also, mention idempotency and exactly-once semantics as critical for deduplication and retries.

1. Clarify Requirements and Scale

Ask about expected throughput, latency SLAs per channel, user preference granularity, and compliance needs. Confirm scale (100M+ users, peak events per second) and define success metrics.

2. Design Event Ingestion and Fan-out

Propose a scalable ingestion layer (e.g., Kafka) to buffer events, then a fan-out service that expands events to per-user, per-channel tasks. Use partitioning and consumer groups for parallelism.

3. Abstract Channels and Handle Preferences

Create a channel abstraction interface with implementations for push, email, SMS, and in-app. Integrate a preference service that checks user opt-ins/opt-outs and channel priorities before dispatch.

4. Implement Reliability: Dedup, Retry, DLQ, Fallback

Use idempotency keys for deduplication, exponential backoff with jitter for retries, and a dead-letter queue for failed messages. Define cross-channel fallback logic (e.g., push fails -> SMS) based on user preferences and urgency.

5. Address Data Model, Rollout, Observability, Abuse

Design a data model for events, preferences, and delivery status. Plan gradual rollout with A/B testing hooks (e.g., feature flags). Instrument metrics, logs, and traces for observability, and implement rate limiting and abuse detection.

Key Points to Mention

Event ingestion with Kafka or similar, ensuring durability and backpressure handling.
Channel abstraction using strategy pattern and adapters for each provider.
User preference service with real-time updates and caching for low-latency checks.
Deduplication via idempotency keys and exactly-once processing semantics.
Retry with exponential backoff, jitter, and dead-letter queue for poison messages.
Cross-channel fallback logic based on user preferences and delivery SLAs.
Data model: events, user preferences, delivery attempts, and status tracking.
Gradual rollout with feature flags and A/B testing for channel effectiveness.
Observability: metrics (latency, success rate), logging, tracing, and alerting.
Abuse prevention: rate limiting, content filtering, and anomaly detection.

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