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

SeniorPrefer not to say

May 2026

Summary

System design round at Google for a software engineering role. The whole thing was one big question about high-throughput event infrastructure and it went deep fast.

Questions Asked (1)

Design a high-throughput event ingestion and subscription system that can handle up to 1 million events per second from fire-and-forget producers, while also supporting clients who register webhook subscriptions with custom matching rules. Cover the rule expression language, registration APIs, webhook delivery with retries and backoff, ordering and filtering guarantees, backpressure, sharding, scalability, multi-tenant isolation, rate limiting, and security.

System DesignTechnical Trade-offsAPI & Integrations

Author's notes

This question is basically a full distributed systems design compressed into one session.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale (1M events/sec, fire-and-forget producers, webhook subscribers with custom matching). Then propose a high-level architecture using a distributed log (e.g., Kafka) for ingestion and a separate matching/delivery pipeline, diving into key components like rule language, sharding, and backpressure. Finally, discuss trade-offs, failure handling, and multi-tenant concerns.

Pro tip: Emphasize decoupling ingestion from delivery to handle backpressure and ensure fire-and-forget semantics; use a write-ahead log and asynchronous processing to avoid blocking producers. Also, highlight the importance of idempotency and at-least-once delivery with deduplication for webhooks.

1. Clarify Requirements and Scale

Ask questions to understand event size, latency requirements, subscription complexity, and isolation needs. Confirm the 1M events/sec throughput and fire-and-forget producer semantics.

2. High-Level Architecture

Propose a layered design: ingestion layer (e.g., Kafka) for durable, partitioned event storage; matching layer to evaluate rules; delivery layer for webhook dispatch with retries. Ensure decoupling for backpressure.

3. Deep Dive into Components

Detail the rule expression language (e.g., JSON-based DSL), registration APIs (REST/gRPC), sharding strategy (by tenant/event key), and webhook delivery with exponential backoff and dead-letter queues.

4. Address Scalability and Isolation

Explain horizontal scaling via partitions, multi-tenant isolation using separate topics/quotas, rate limiting per tenant, and security (authn/authz, TLS, payload encryption).

5. Discuss Trade-offs and Guarantees

Cover ordering (per-key ordering vs global), filtering (server-side vs client-side), at-least-once vs exactly-once delivery, and how to handle failures (retries, circuit breakers).

Key Points to Mention

Rule expression language design: use a declarative DSL (e.g., JSON-based) for matching, with support for complex predicates and efficient evaluation.
Sharding and partitioning: shard events by tenant or event key to enable parallel processing and maintain ordering where needed.
Webhook delivery: implement retries with exponential backoff and jitter, dead-letter queues, and idempotency keys to handle duplicates.
Backpressure: decouple ingestion from delivery using a durable log; if subscribers are slow, buffer or drop with monitoring.
Multi-tenant isolation: enforce quotas, rate limits, and resource isolation per tenant to prevent noisy neighbors.
Security: authenticate producers and subscribers, authorize subscriptions, encrypt data in transit and at rest, and validate webhook endpoints.

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