Skip to content

Uber Interview Guide

Uber’s coding rounds lean practical and systems-flavoured: problems that look like something the company would actually compute — matching riders to drivers, rate limiting, geospatial lookups, routing over a road network. Graph algorithms and design-shaped questions recur more than pure combinatorial puzzles.

The useful preparation shift is to expect problems phrased as a scenario rather than an abstract statement, and to be comfortable turning that scenario into a model before you start solving.

Strong bias toward problems with a geographic or scheduling flavour — graphs on maps, intervals over time, matching supply to demand.

The loop

Online assessment 1× · 60-90 min 2 auto-graded problems
Technical screen 1× · 45 min One medium
Onsite 3-4× · 45-60 min Coding, plus system design at senior levels

The bar

Model the problem before coding it. Uber's questions often hide a standard algorithm behind a domain story, and naming the algorithm out loud is half the answer.

What they lean on

This is the durable part. Which pattern families a company favours is far more stable than which individual problems it uses, so prepare in this order:

  1. shortest-paths-dijkstra-bellman-ford-and-floyd-warshall
  2. merge-intervals
  3. sweep-line-and-event-counting
  4. grid-traversal-islands-and-flood-fill
  5. top-k-elements
  6. greedy-interval-scheduling

Quirks worth knowing

  • Interval and sweep-line problems appear far above their base rate. Drill Phase 07 specifically.
  • Expect "now it must run in real time on a million drivers" as a follow-up.

Reported problems

38 problems
4 easy26 medium8 hard
  • Solving before modelling. These problems arrive as scenarios. Say out loud what the nodes and edges are, or what the state is, before writing anything — getting the model wrong is the expensive failure here.
  • Forgetting the graph is weighted. “Fewest steps” cues BFS; road networks have distances. One weighted edge and you need Dijkstra — or 0-1 BFS if the weights are only 0 and 1.
  • Ignoring the operational angle. These are systems people. What happens when a driver disconnects, when the request rate spikes, when two matches collide? Naming a failure mode unprompted lands well.
  • Treating design questions as pure algorithms. A rate limiter question wants the bucketed, bounded-memory answer, not just a correct one.
They askWhat they’re checkingThe answer
“Model this as a graph. What are the nodes?”Whether you can turn a scenario into a structureAnswer explicitly — intersections as nodes and roads as weighted edges, or riders and drivers as the two sides of a bipartite graph. The model is most of the solution.
“The edges have travel times now.”BFS’s preconditionBFS is only shortest-path-correct on uniform costs. Switch to Dijkstra at O(ElogV)O(E \log V); if the weights are only 0 and 1, 0-1 BFS with a deque keeps it linear.
“What if there are millions of requests per second?”Bounded memoryBucket by time: a fixed array of slots keyed by t % window, holding (timestamp, count). O(1)O(1) time and O(1)O(1) space regardless of traffic — how real rate limiters are built.
“What breaks in production?”Operational instinctName a concrete failure and a mitigation — stale driver locations, a hot partition, a retry storm. Volunteering this is a differentiator.
  • Problems arrive as scenarios. Model first — name the nodes, edges, or state out loud before solving.
  • Weighted graphs, not just BFS. Road networks have distances: Dijkstra, or 0-1 BFS for 0/1 weights.
  • Design questions want bounded memory — the bucketed rate limiter, not merely a correct one.
  • Volunteer a failure mode. Disconnections, spikes, retry storms. These are systems people.
  • Graph and design families dominate the recurring pattern list below.

pch.coffeeTagline

pch.coffeeCta

pch.feedbackHeading

pch.feedbackSubheading