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

Senior

Apr 2026

Summary

System design round at Coinbase for a software engineer role, focused entirely on real-time stock price delivery at scale. One long question that kept branching into sub-topics for the whole session.

Questions Asked (1)

Design a system that delivers real-time stock prices to millions of concurrent clients. Cover data ingestion from market feeds, symbol normalization and deduplication, how updates get pushed to clients, API design and throttling, caching and fan-out, latency and consistency tradeoffs, backpressure, horizontal scaling, fault tolerance across regions, and how you'd monitor and test the whole thing.

System DesignTechnical Trade-offsAPI & Integrations

Author's notes

This one sprawled in every direction.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale (e.g., number of symbols, update frequency, latency targets), then design a high-level architecture covering ingestion, processing, and delivery. Dive into key components like normalization, fan-out, and backpressure, and discuss tradeoffs (latency vs. consistency, cost vs. performance) and fault tolerance. Conclude with monitoring and testing strategies.

Pro tip: Emphasize the importance of idempotent processing and exactly-once semantics in the ingestion pipeline to handle duplicate or out-of-order market data, which is critical for financial systems. Also, discuss how you would handle symbol mapping across different exchanges and the need for a canonical symbol registry.

1. Clarify Requirements and Scale

Ask questions to understand the scale: number of symbols, expected update rate (e.g., 1M updates/sec), number of concurrent clients (millions), latency requirements (e.g., sub-second), consistency needs (e.g., eventual vs. strong), and geographic distribution.

2. High-Level Architecture

Outline the main components: data ingestion from multiple market feeds, normalization and deduplication service, a pub/sub system for distribution, caching layers, and edge servers for client delivery. Sketch a diagram showing data flow.

3. Deep Dive into Key Components

Detail the ingestion pipeline (e.g., using Kafka for buffering), normalization (mapping symbols to canonical IDs, deduplication via sequence numbers), fan-out (using a distributed pub/sub like Redis or custom), and client delivery (WebSockets, SSE, or long polling). Discuss API design (REST for queries, WebSocket for streaming) and throttling (rate limiting per client, backpressure handling).

4. Address Tradeoffs and Scalability

Discuss latency vs. consistency (e.g., using eventual consistency for scalability), caching strategies (in-memory caches at edge, TTL), horizontal scaling (sharding by symbol, partitioning), and fault tolerance (multi-region replication, failover). Explain backpressure mechanisms (e.g., dropping updates or slowing ingestion).

5. Monitoring, Testing, and Operations

Describe monitoring (metrics like latency, throughput, error rates; tracing; alerting), testing (load testing, chaos engineering, simulation of market data), and deployment (canary releases, blue-green). Mention logging and debugging tools.

Key Points to Mention

Use of a message queue (e.g., Kafka) for ingestion to handle high throughput and provide backpressure.
Symbol normalization and deduplication using a canonical symbol registry and sequence numbers to ensure data integrity.
Fan-out architecture with pub/sub and edge caching to scale to millions of clients with low latency.
API design: WebSocket for real-time streaming, REST for historical queries, with rate limiting and throttling per client.
Tradeoffs: latency vs. consistency (e.g., eventual consistency for scalability), cost vs. performance (e.g., edge caching).
Fault tolerance: multi-region deployment, replication, and failover strategies; monitoring with metrics, tracing, and alerting.

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