rippling·Software Engineer·Technical Phone Screen·Senior

SeniorPrefer not to say

May 2026Remote

Summary

Rippling SWE interview with a meaty OOP design problem. The question had way more moving parts than I expected and the discussion went pretty deep into tradeoffs around money precision, concurrency, and idempotency.

Questions Asked (1)

Design an in-memory Delivery Cost System for a food-delivery company. It should support registering drivers with hourly rates, recording completed deliveries, computing total cost, marking costs as paid up to a given timestamp (with partial-delivery proration), returning unpaid amounts, and finding the max number of simultaneously active drivers in the past 24 hours.

System DesignAlgorithms & Data StructuresTechnical Trade-offs

Author's notes

This looked like a clean OOP question until I started actually thinking through the edge cases.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and constraints (e.g., scale, timestamp precision, driver activity definition). Then design data structures and algorithms for each operation, focusing on efficient time-based queries and proration logic. Finally, discuss trade-offs and potential optimizations.

Pro tip: Emphasize the use of time-ordered data structures (like balanced BSTs or segment trees) for efficient range queries and updates, and clearly explain how you handle partial deliveries during payment marking.

1. Clarify Requirements and Constraints

Ask about expected scale (number of drivers, deliveries per day), timestamp granularity, definition of 'active driver' (e.g., during a delivery), and whether payments can be partial or must be for whole deliveries.

2. Design Data Structures

Propose structures: a map for driver rates, a list or tree of deliveries sorted by time, and a segment tree or interval tree for tracking driver activity to answer max concurrency queries.

3. Implement Core Operations

Detail algorithms for registering drivers, recording deliveries (updating activity intervals), computing total cost (sum of rate * duration), and marking costs as paid up to a timestamp with proration for partial deliveries.

4. Handle Time-Based Queries

Explain how to efficiently find the maximum number of simultaneously active drivers in the past 24 hours using a sliding window or segment tree with lazy propagation.

5. Discuss Trade-offs and Optimizations

Compare approaches (e.g., segment tree vs. sweep line), discuss time/space complexity, and suggest optimizations like caching or batch processing for high throughput.

Key Points to Mention

Use of time-ordered data structures (e.g., balanced BST, segment tree) for efficient range queries and updates.
Proration logic for partial deliveries when marking costs as paid: calculate cost up to the timestamp, possibly splitting a delivery's cost proportionally.
Definition of driver activity: consider intervals from delivery start to end, and handle overlapping intervals for concurrency.
Efficient max concurrency query: use sweep line algorithm or segment tree with range updates and max queries.
Handling of timestamps: ensure consistency (e.g., Unix epoch) and consider time zones if needed.
Scalability considerations: sharding by driver or time, and potential use of in-memory databases or caching.

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