← Whatnot Interview InsightsSoftware Engineer

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

Intermediate
Apr 2026

Summary

System design round at Whatnot for a software engineer role. The prompt was building a charity donation site that hooks into a third-party payment vendor, with most of the conversation focused on async processing and message queues.

Questions Asked (1)

Q1

Design a charity donation website that integrates with a third-party payment vendor. The core focus is on how you handle asynchronous processing and message queues for donation transactions.

System DesignAPI & IntegrationsTechnical Trade-offs
Author's notes

The third-party integration part felt straightforward at first but the async angle is where it got interesting.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale, then design a high-level architecture with a clear separation between synchronous user-facing flows and asynchronous payment processing. Focus on how message queues decouple donation intake from payment vendor interactions, ensuring reliability, idempotency, and failure handling. Discuss trade-offs between consistency, latency, and complexity, and how you would monitor and scale the system.

Pro tip: Emphasize idempotency and exactly-once processing semantics, as payment systems are prone to duplicate charges and race conditions. Show you understand the vendor's webhook retry behavior and design your system to handle out-of-order and duplicate events gracefully.

1. Clarify Requirements and Scale

Ask about expected traffic, donation volume, payment vendor capabilities (webhooks, idempotency keys), and consistency requirements. Establish functional and non-functional requirements like latency, throughput, and fault tolerance.

2. High-Level Architecture

Sketch the main components: web/app servers, API gateway, donation service, message queue (e.g., Kafka, RabbitMQ, SQS), payment service, database, and third-party payment vendor. Show how donations are accepted synchronously and then processed asynchronously.

3. Asynchronous Processing with Queues

Detail how donation events are published to a queue after initial validation, and how workers consume messages to interact with the payment vendor. Explain retry logic, dead-letter queues, and backoff strategies for transient failures.

4. Idempotency and Consistency

Describe how to ensure exactly-once processing using idempotency keys, deduplication, and transactional outbox patterns. Discuss how to handle webhook callbacks from the payment vendor and update donation status consistently.

5. Monitoring, Scaling, and Trade-offs

Cover monitoring (queue depth, processing latency, error rates), scaling consumers horizontally, and trade-offs between consistency models (e.g., eventual vs. strong consistency) and system complexity.

Key Points to Mention

  • Idempotency keys for both outbound payment requests and inbound webhook events to prevent duplicate charges.
  • Message queue selection (e.g., Kafka for high throughput, SQS for simplicity) and its role in decoupling services.
  • Retry mechanisms with exponential backoff and dead-letter queues for failed payment attempts.
  • Transactional outbox pattern to atomically update database and publish events to the queue.
  • Webhook handling from payment vendor: verifying signatures, handling out-of-order events, and updating donation status.
  • Monitoring and alerting on queue lag, payment success rates, and error rates to ensure system health.

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