Uber Interview Questions

I've spent five years building distributed backend systems, most recently leading infrastructure at a high-scale startup where I optimized microservices handling millions of requests daily. I'm drawn to problems where reliability and performance directly impact user experience—I redesigned our payment processing pipeline, reducing latency by 40% and improving fault tolerance. What excites me about Uber is your approach to real-time coordination at global scale. I'm looking to bring my expertise in system design and cross-functional collaboration to solve complex infrastructure challenges.

Use BFS tracking (current_stop, routes_used). Build a stop-to-routes map for O(1) lookups of which routes serve each stop. From source, explore all unvisited stops on each available route, incrementing the route counter. Return when destination is reached. Key insight: BFS explores stops layer-by-layer by number of routes, guaranteeing the first destination arrival is the minimum.

Iterate through each grid cell. When you find an unvisited land cell, it's a new island—use DFS to recursively mark all connected cells as visited. Increment the island count and continue. The key insight: tracking visited cells ensures each land cell contributes to exactly one island. By processing systematically and avoiding revisits, you count each distinct connected component once.

API design: POST /messages (send message), GET /conversations/:id/messages (fetch with pagination), PATCH /messages/:id/read (mark read). Database schema: conversations table (id, type, participants), messages table (id, conversation_id, sender_id, text, timestamp), read_receipts table (message_id, user_id, read_at). Architecture: message broker (Kafka) decouples producers from consumers; fanout ensures all participants receive messages. Redis caches recent messages and read status. WebSocket enables real-time delivery. Key: timestamp-ordered messages prevent inconsistency; decouple read receipts from message flow for performance. Index on conversation_id, user_id.

Combine a HashMap with a doubly-linked list. The HashMap maps keys to nodes for O(1) lookups; the list tracks recency order with the most-recently-used at the head and least-recently-used at the tail. Get: retrieve the node and move it to the head. Put: add to the head; if at capacity, evict the tail node. All operations—lookups, insertions, deletions, and node movement—execute in O(1) because they're direct pointer manipulations independent of cache size.

Use a distributed Calendar Service sharded by user ID, storing events in a time-indexed database (e.g., B-trees or interval trees for O(log n) conflict queries). Before booking, query the Conflict Detection Engine against the user's calendar. Cache hot calendars in Redis. Use transactional writes with optimistic locking to prevent race conditions during concurrent bookings. For scale, shard calendars and use a queue for async processing. Handle timezones via UTC normalization. Real-time sync via WebSocket push.

Identify character orderings by comparing adjacent words—the first differing character means char_a precedes char_b. Construct a directed graph of these dependencies. Perform DFS-based topological sort: for each unvisited character, explore descendants and append to result in reverse finish order. Key insight: the problem reduces to finding a topological ordering of a character-dependency DAG; any valid topological sort respects all word-order constraints.

I've held both formal and informal leadership roles. In my last position, I owned a cross-functional initiative to reduce system latency. I drove alignment across backend, frontend, and DevOps teams through weekly syncs and documented milestones. By breaking down the problem and delegating effectively, we cut p99 latency by 40% in three months. I learned that leadership at Uber means taking ownership of outcomes, unblocking teammates, and pushing for measurable impact—not just title.

I'm drawn to Uber's core mission: making mobility seamless at planetary scale. Your platform powers billions of rides globally, solving real infrastructure problems millions encounter daily. What excites me most is the technical complexity—building reliable real-time systems, optimizing distributed algorithms, and leveraging data science with direct consumer impact. I'm motivated by roles where engineering excellence drives business outcomes. Uber's reputation for tackling hard systems problems aligns perfectly with my growth goals as a systems engineer.

Organize parking across multiple levels with spaces categorized by type (compact, regular, large). Include entry/exit control, real-time availability tracking, and payment processing.

Low-level: Define ParkingLot, Level, Space, Vehicle, Ticket, Payment classes. Track free spaces per type with HashMap<SpaceType, Queue<Space>>. Implement findSpace() (best-fit), parkVehicle() (reserve), unparkVehicle() (release and charge). Abstract payment via PaymentProcessor interface for flexibility.

We disagreed on caching strategy—my teammate preferred simple TTL; I pushed for more complex invalidation logic. Rather than escalate, I proposed a benchmark: implement both and compare real impact on p99 latency. The data showed my approach reduced tail latencies by 30%, but added maintenance burden. We compromised: mine for hot paths, his elsewhere. This taught me that being right matters less than being collaborative. At Uber, speed comes from aligned teams, not solo heroes.

I owned a microservice optimization project for our matching system. After profiling identified database queries as the bottleneck, I designed a distributed caching layer that reduced P99 latency by 40%. I collaborated with data engineers to define TTL policies and coordinated rollout across regions. The improvement enabled faster ride matches for millions of users daily. I also mentored junior engineers through the implementation, which became our template for future optimizations.

Uber Eats uses a microservices architecture: API Gateway routes to independent Order, Restaurant, User, and Delivery services. PostgreSQL handles transactional data (orders, payments) with strong consistency; Cassandra/MongoDB scale non-critical data (reviews, metrics). Kafka enables async inter-service communication. Redis caches restaurants and sessions. Elasticsearch indexes restaurants/dishes. WebSockets provide real-time order tracking and notifications. A CDN serves static assets. Key insight: prioritize consistency for payments, eventual consistency elsewhere. Use load balancing and horizontal scaling for reliability.

I led a microservices migration for a payment processing system handling 50K+ daily transactions. The goal was reducing latency and improving reliability. I owned the entire design end-to-end: I chose event-driven architecture with message queues, determined the database sharding strategy by analyzing traffic patterns, and established clear service boundaries. I made technical decisions based on load testing results, not assumptions, and collaborated closely with frontend and ops teams on implementation. The result: P99 latency dropped 40%, system reliability reached 99.95%, and we achieved 3x throughput without adding servers.

I once submitted a PR with inefficient database queries that passed tests but would have caused latency issues at scale. A senior engineer caught this and explained the performance implications. Rather than defend the approach, I asked them to walk me through better indexing strategies. I refactored the code and started reviewing database performance proactively in my own PRs. This feedback shaped how I think about scalability—I now model systems with production load in mind, not just correctness.

For classic concurrency problems (Producer-Consumer, Readers-Writers), apply these principles: use a lock to protect shared state, condition variables to coordinate thread advancement. Producers acquire the lock, check if buffer is full (wait if so), add the item, notify consumers. Consumers mirror this: acquire lock, wait if empty, consume, notify producers. The key insight: separate mutex protection from signaling to avoid spurious wakeups and race conditions. Think through deadlock—ensure circular waiting chains are impossible.

Most binary tree problems yield to recursive DFS—process nodes top-down while threading results back up. The key insight: use the return value to encode information (subtree validity, height, matched nodes). Pre-order for validation/modification, post-order for aggregation. Optimize via early termination (null checks, flag-based pruning). Uber values recognizing when a single DFS pass solves what looks like multiple traversals—that's O(n) instead of O(kn).

I want to grow into a technical leader who drives impact on problems at massive scale. I'm drawn to Uber because you solve complex challenges—logistics, real-time systems, global infrastructure—where engineering decisions directly affect millions of users. Short-term, I aim to become a go-to expert in my domain, owning features end-to-end and mentoring others. Long-term, I'd like to lead a team or technical program that shapes product strategy. I'm committed to continuous learning and thrive in high-velocity environments where I can take ownership, iterate quickly, and measure real impact.