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

SeniorPrefer not to say

Apr 2026

Summary

Uber SWE low-level design round, one question, sixty minutes on the clock. Got it working but left feeling like I needed another half hour to clean things up.

Questions Asked (1)

Build a working Splitwise clone with running code within 60 minutes.

System DesignData ModelingTechnical Trade-offs

Author's notes

The design itself wasn't the hard part, I had a reasonable mental model pretty fast.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying core requirements (users, groups, expenses, splits, balances) and then design a minimal data model with users, groups, expenses, and balances. Implement a working prototype focusing on the happy path: adding an expense with equal/unequal splits and updating balances, using an in-memory store for speed. Discuss trade-offs like consistency vs. availability and how you'd scale to Uber's scale.

Pro tip: Prioritize a working end-to-end flow over perfect code; demonstrate you can make pragmatic trade-offs under time pressure. Mention how you'd handle concurrency and idempotency in a real system.

1. Clarify Requirements and Scope

Ask clarifying questions to define MVP: user management, group creation, expense recording with splits (equal, exact, percentage), and balance calculation. Confirm whether to include debt simplification and persistence.

2. Design Data Model and API

Sketch entities: User, Group, Expense, Split, Balance. Define key operations: addExpense, getBalances, settleUp. Choose an in-memory store (e.g., dictionaries) for speed.

3. Implement Core Logic

Code the happy path: create users/groups, add an expense with splits, update balances. Use a simple algorithm to compute net balances per user per group.

4. Test and Demo

Run a quick test scenario: add users, create group, add expenses, print balances. Ensure the code runs and handles basic edge cases like zero amounts.

5. Discuss Trade-offs and Scaling

Explain design decisions: in-memory vs. persistent, consistency models, and how to scale (sharding by group, caching balances). Mention concurrency control (e.g., optimistic locking) and idempotency.

Key Points to Mention

Data model: users, groups, expenses, splits, and balances with proper relationships.
Balance calculation algorithm: net amount per user, considering who paid and who owes.
Trade-offs: in-memory for speed vs. persistence for durability; consistency vs. availability.
Concurrency handling: preventing race conditions when multiple users add expenses simultaneously.
Scalability: sharding by group ID, caching, and asynchronous balance updates.
Debt simplification: optional feature to minimize transactions, with algorithmic complexity discussion.

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