← Whatnot Interview InsightsSoftware Engineer

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

Senior
Jun 2026

Summary

System design round at Whatnot for a software engineer role. Pretty standard stuff, though the follow-ups pushed a bit deeper than I expected.

Questions Asked (3)

Q1

Design a platform similar to LeetCode, including its core features and architecture.

System DesignTechnical Trade-offsData Modeling
Author's notes

Classic question and I knew it going in.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale (e.g., number of users, problems, submissions per day) to scope the design. Then outline the high-level architecture, focusing on core components like problem management, code execution, and submission handling. Finally, dive into data modeling and trade-offs for key components, ensuring scalability and reliability.

Pro tip: Emphasize the importance of a secure and scalable code execution environment, as it's the most challenging part. Discuss using containerization and sandboxing to isolate user code, and consider trade-offs between latency and cost.

1. Clarify Requirements and Scale

Ask questions to understand expected user base, problem set size, submission frequency, and supported languages. This informs capacity planning and technology choices.

2. High-Level Architecture

Sketch the main components: web/app servers, database, code execution service, caching, and message queue. Explain how they interact to handle user requests and submissions.

3. Data Modeling

Design schemas for problems, test cases, submissions, and user progress. Consider using a relational database for structured data and a NoSQL store for scalability if needed.

4. Code Execution Service

Detail how to run untrusted code securely and efficiently. Discuss containerization (e.g., Docker), orchestration (e.g., Kubernetes), resource limits, and result collection.

5. Scalability and Trade-offs

Address scaling strategies (horizontal scaling, caching, sharding) and trade-offs (e.g., consistency vs. availability, cost vs. performance). Mention monitoring and fault tolerance.

Key Points to Mention

  • Use of message queues (e.g., RabbitMQ, Kafka) to decouple submission handling and enable asynchronous processing.
  • Caching strategies (e.g., Redis) for frequently accessed problems and leaderboards.
  • Database sharding or partitioning for submissions and user data as scale grows.
  • Security measures for code execution: sandboxing, resource limits (CPU, memory, time), and network isolation.
  • Support for multiple programming languages via pre-built execution environments.
  • Monitoring and logging for system health and debugging, using tools like Prometheus and ELK stack.

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

Q2

How do signed URLs work, and when would you use them?

System DesignAPI & Integrations
Author's notes

Came up as a follow-up and I fumbled the explanation a bit.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by defining signed URLs as URLs with a cryptographic signature that grants temporary access to a specific resource, then explain the mechanism (e.g., HMAC or RSA signing of a policy) and highlight key benefits like security and scalability. Finally, discuss when to use them, such as for private file downloads, time-limited access, or offloading bandwidth, and relate to system design trade-offs.

Pro tip: Emphasize that signed URLs should be generated server-side and never expose secrets; also mention that they can include constraints like IP restrictions or HTTP method limitations to enhance security.

1. Define signed URLs

Explain that a signed URL contains a signature (e.g., HMAC) that authenticates the request and often includes an expiration time and permissions.

2. Explain how they work

Describe the process: a server generates a URL with a signature using a secret key, and the storage service verifies the signature before granting access.

3. Discuss benefits

Highlight advantages like secure temporary access, reduced server load by offloading to CDN/storage, and fine-grained control over permissions.

4. Identify use cases

Give examples: private file downloads, time-limited access to media, uploads to cloud storage, and protecting API endpoints.

5. Consider trade-offs and best practices

Mention limitations (e.g., revocation difficulty) and best practices (short expiration, HTTPS, server-side generation).

Key Points to Mention

  • Cryptographic signing (HMAC, RSA) and verification process
  • Expiration time and permission scoping (e.g., read/write, IP restrictions)
  • Use cases: private content delivery, temporary uploads, API authentication
  • Security benefits: no need to expose credentials, reduces attack surface
  • Scalability: offloads serving to CDN or object storage
  • Best practices: short TTL, HTTPS, server-side generation, avoid embedding secrets

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

Q3

How would you scale the platform to support live competitions with many concurrent users?

System DesignTechnical Trade-offs
Author's notes

This one was fun.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the requirements and constraints of live competitions, such as expected concurrent users, latency, and consistency needs. Then propose a scalable architecture that separates real-time interactions from backend processing, using techniques like WebSockets, pub/sub, and horizontal scaling. Finally, discuss trade-offs between consistency, availability, and cost, and how you would validate the design with load testing and monitoring.

Pro tip: Emphasize the importance of idempotency and graceful degradation during peak loads, as live competitions can have unpredictable spikes. Show that you consider both technical and product implications, like user experience during failures.

1. Clarify Requirements

Ask about expected scale (e.g., number of concurrent users, events per second), latency requirements, consistency needs, and budget constraints. This ensures your design targets the right problems.

2. High-Level Architecture

Outline a scalable architecture: load balancers, stateless services, real-time communication layer (WebSockets/SSE), message queues, and a distributed cache. Mention separating read and write paths for scalability.

3. Real-Time Data Flow

Explain how live updates (scores, bids, etc.) are propagated: use pub/sub (e.g., Redis Pub/Sub, Kafka) to fan out events to connected clients, and consider edge caching or CDN for static assets.

4. Scalability & Reliability

Discuss horizontal scaling of services, database sharding/replication, and handling failures with retries, circuit breakers, and fallbacks. Mention auto-scaling and load testing.

5. Trade-offs & Validation

Articulate trade-offs (e.g., consistency vs. latency, cost vs. performance) and how you would validate the design through load testing, monitoring, and gradual rollouts.

Key Points to Mention

  • Use of WebSockets or Server-Sent Events for real-time bidirectional communication.
  • Pub/sub messaging (e.g., Kafka, Redis) to decouple producers and consumers and handle high throughput.
  • Horizontal scaling with stateless services and load balancers; auto-scaling groups.
  • Database strategies: read replicas, sharding, and eventual consistency for high write loads.
  • Caching layers (Redis, CDN) to reduce latency and backend load.
  • Idempotency and exactly-once processing to handle duplicate events during retries.
  • Graceful degradation and fallback mechanisms (e.g., queueing writes, serving stale data).
  • Load testing and monitoring to identify bottlenecks and ensure reliability.

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