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

SeniorPrefer not to say

Apr 2026

Summary

System design round at Coinbase focused entirely on designing the Explore page. Dense question with a lot of moving parts, probably more than I expected going in.

Questions Asked (1)

Design the Coinbase Explore page, covering what users see, the data model, ranking and personalization, price data freshness, caching, API contract, mobile vs web considerations, and graceful degradation under load or partial failures.

System DesignTechnical Trade-offsData Modeling

Author's notes

This thing is basically five questions stitched into one.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scope, then design a high-level architecture that separates data ingestion, ranking/personalization, and serving layers. Walk through each component (data model, caching, API, client considerations, degradation) while explicitly calling out trade-offs and failure modes. Emphasize how the design meets Coinbase's needs for low latency, high availability, and regulatory compliance.

Pro tip: Proactively discuss how you would handle partial failures and data staleness—interviewers love candidates who design for resilience from the start, not as an afterthought. Also, tie your choices back to Coinbase's mission of being the most trusted crypto platform.

1. Clarify Requirements and Scope

Ask questions to understand functional and non-functional requirements: what assets to show, personalization depth, latency targets, consistency needs, and mobile vs web constraints. Define success metrics like engagement and freshness.

2. Design Data Model and Ingestion

Propose schemas for assets, prices, user profiles, and interactions. Describe how to ingest real-time price data from exchanges and batch user events, ensuring scalability and fault tolerance.

3. Architect Ranking and Personalization

Outline a ranking pipeline that combines real-time signals (e.g., price changes) with batch-computed user preferences. Discuss trade-offs between precomputed and on-the-fly ranking, and how to handle cold-start users.

4. Define API Contract and Caching Strategy

Specify API endpoints (e.g., GET /explore) with response schema, pagination, and error handling. Design a multi-layer caching strategy (CDN, Redis, in-memory) with appropriate TTLs and invalidation for price data.

5. Address Client Differences and Degradation

Explain how mobile and web clients differ in rendering, data fetching, and offline support. Describe graceful degradation: fallback to cached or static content, circuit breakers, and load shedding under high traffic.

Key Points to Mention

Data freshness: use WebSockets or server-sent events for real-time price updates, with fallback to polling; set TTLs based on asset volatility.
Caching layers: CDN for static assets, Redis for ranked lists, and client-side caching; discuss cache invalidation and consistency trade-offs.
Personalization: hybrid approach using collaborative filtering and content-based signals; ensure explainability and avoid filter bubbles.
API design: RESTful with cursor-based pagination, versioning, and rate limiting; include ETags for conditional requests.
Mobile vs web: mobile may use GraphQL for efficient data fetching, web may use REST; consider offline mode and push notifications.
Graceful degradation: circuit breakers, fallback to stale data, feature flags to disable personalization, and load shedding via priority queues.

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