Uber·Software Engineer·Technical Phone Screen·Intermediate

IntermediatePrefer not to say

Apr 2026Remote

Summary

Phone screen for a SWE role at Uber, one coding/design question the whole time. The problem sounds deceptively simple until you realize they want true O(1) and won't accept a scan.

Questions Asked (2)

Design a data structure that tracks a stream of website visits by customer ID and supports two operations: recording a visit, and returning the earliest customer who has visited exactly once so far. Both operations must run in constant time.

Algorithms & Data StructuresSystem Design

Author's notes

I started with a hashmap for counts and thought I was done.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Clarify the requirements and constraints, then propose a design using a doubly linked list to maintain the order of unique visitors and a hash map for O(1) access to nodes. Explain how to handle duplicate visits by removing the customer from the list when their count exceeds one, ensuring both operations remain constant time.

Pro tip: Mention that this is a classic LRU cache variant, and discuss how to handle edge cases like a customer visiting again after being removed, or memory management for large streams.

1. Clarify Requirements

Ask questions to confirm assumptions: Is the stream infinite? Can customer IDs be reused? What should happen if no customer has visited exactly once? This shows thoroughness.

2. Choose Data Structures

Select a hash map to store customer visit counts and a doubly linked list to maintain the order of customers with exactly one visit. Explain why these enable O(1) operations.

3. Define Operations

Detail the recordVisit operation: increment count, and if count becomes 1, add to the end of the list; if count becomes 2, remove from the list. For getEarliestUnique, return the head of the list if it exists.

4. Handle Edge Cases

Discuss scenarios like a customer visiting again after being removed (count >2), empty list, and memory constraints. Explain how the design handles these.

5. Analyze Complexity

Confirm that both operations are O(1) time and O(n) space, where n is the number of unique customers. Mention any trade-offs.

Key Points to Mention

Use of a doubly linked list to maintain insertion order of unique visitors
Hash map to track visit counts and node references for O(1) access
Removal from the linked list when a customer's visit count exceeds one
Handling of duplicate visits and potential re-insertion if count resets (though not required)
Time and space complexity analysis: O(1) for both operations, O(n) space
Comparison to LRU cache design pattern

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

How would you scale this system to handle tens of millions of visit events per second?

System DesignTechnical Trade-offs

Author's notes

They asked this right after I finished the coding part.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the requirements and constraints, such as event size, latency, and durability. Then propose a scalable architecture that distributes load across multiple layers, using partitioning, sharding, and asynchronous processing. Finally, discuss trade-offs between consistency, availability, and cost, and how to monitor and adapt the system.

Pro tip: Emphasize that scaling to tens of millions of events per second requires a shift from traditional request-response to a streaming data pipeline, and highlight the importance of backpressure and graceful degradation to maintain system stability.

1. Clarify Requirements and Constraints

Ask about event size, required latency, durability guarantees, and query patterns to understand the problem scope. This ensures your solution addresses the actual needs.

2. Design a Distributed Ingestion Layer

Propose a horizontally scalable ingestion tier using load balancers, API gateways, and a partitioned message queue like Kafka to absorb and buffer the high volume of events.

3. Implement Scalable Processing and Storage

Use stream processing frameworks (e.g., Flink, Spark Streaming) to process events in real-time, and store data in a sharded, distributed database or data lake optimized for high write throughput.

4. Address Trade-offs and Failure Modes

Discuss trade-offs between consistency and availability, and how to handle failures with replication, retries, and dead-letter queues. Mention monitoring and autoscaling.

5. Summarize and Validate

Recap the architecture, highlighting how it meets the scale requirement, and invite feedback or further questions to show collaboration.

Key Points to Mention

Horizontal scaling and partitioning (e.g., sharding by user ID or event type)
Use of a distributed message queue (e.g., Apache Kafka) for buffering and decoupling
Stream processing for real-time aggregation and analytics (e.g., Apache Flink)
Storage solutions optimized for high write throughput (e.g., Cassandra, Bigtable, or data lakes)
Trade-offs: consistency vs. availability, latency vs. cost, and exactly-once vs. at-least-once processing
Monitoring, alerting, and autoscaling to handle traffic spikes and ensure reliability

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