← WHOOP Interview Insights

WHOOP·Mobile Engineer·Onsite - System Design / Architecture·Senior

SeniorPrefer not to say
Apr 2026

Summary

WHOOP system design round for a mobile engineer role. Two pretty stern interviewers, not a lot of warmth in the room, and they pushed hard to skip past the problem-clarification phase and just start coding. Managed to get to a working solution but it was a grind and I left feeling like I'd only half-understood what they actually wanted.

Questions Asked (1)

Q1

Design a BLE command handler for a mobile app where commands must be sent serially, meaning the next command can only be dispatched after the previous one receives a response or times out.

System DesignAPI & IntegrationsTechnical Trade-offs
Author's notes

Got partway there but my framing kept drifting toward firmware concepts instead of thinking about it from the mobile app side.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements: BLE characteristics, command/response format, timeout duration, and error handling. Then propose a serial command queue with a state machine that dispatches one command at a time, waits for response or timeout, and handles retries and errors. Finally, discuss trade-offs like queue overflow, cancellation, and testing strategies.

Pro tip: Emphasize idempotency and command IDs to handle duplicate responses or retries safely, and mention that you'd make the timeout configurable per command type for flexibility.

1. Clarify Requirements and Constraints

Ask about BLE profile (GATT characteristics), command/response format, expected timeout, concurrency needs, and error handling expectations. This ensures the design meets the specific use case.

2. Design the Serial Command Queue

Propose a FIFO queue that holds commands. A dispatcher dequeues one command at a time, sends it over BLE, and waits for a response or timeout before proceeding.

3. Implement State Machine and Timeout Handling

Define states: IDLE, SENDING, WAITING_FOR_RESPONSE, TIMEOUT, ERROR. Use a timer to enforce timeout; on timeout, either retry or fail the command and move to the next.

4. Handle Responses and Errors

Match responses to commands using command IDs. Handle error responses, retries with backoff, and ensure the queue continues processing even after failures.

5. Discuss Trade-offs and Edge Cases

Cover queue overflow, cancellation of pending commands, thread safety, and testing strategies (unit tests with mocked BLE, integration tests).

Key Points to Mention

  • Use a serial queue (FIFO) with a single dispatcher to enforce one command at a time.
  • Implement a state machine to manage command lifecycle: idle, sending, waiting, timeout, error.
  • Use command IDs to correlate responses and handle out-of-order or duplicate responses.
  • Set a configurable timeout per command type and handle timeouts with retries or failure.
  • Ensure thread safety if BLE callbacks occur on a different thread (e.g., use locks or serial dispatch queue).
  • Consider edge cases: queue overflow, command cancellation, and BLE disconnection/reconnection.

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