# How Uber Knows Your Driver Is 7 Minutes Away

> Source: <https://dev.to/lovestaco/how-uber-knows-your-driver-is-7-minutes-away-ao3>
> Published: 2026-09-11 20:24:22+00:00

*Hello, I'm Maneshwar, and I'm building LiveReview — a blast-radius aware AI code review built for your business-critical systems. [Star us](https://github.com/HexmosTech/LiveReview/) to help devs discover the project, give it a try, and share your feedback to help improve the product.*

Your Uber says the driver is 7 minutes away.

They show up in 7 minutes.

That is not a lucky guess, that is one of the more quietly insane systems in consumer tech, and it is worth taking apart.

Uber does not think about roads, it thinks about road *segments*.

A single road gets cut into a handful of pieces, and globally Uber is tracking around 100 million of these segments.

Each segment has a number attached to it: how long it takes to cross, right now.

To get from your driver to you, the routing engine finds the fastest path through these segments and adds up the crossing times along the way.

That sum is your ETA.

Simple enough, except that number, "how long it takes to cross this segment", is not a constant.

It is 20 seconds at 2am and 2 minutes at 6pm on a Friday, on the exact same 200 meters of road.

The obvious move is to buy this traffic data from someone who already maps the whole planet.

Uber doesn't. Uber measures it.

Every driver on the platform is already pinging their location every 4 seconds, because that's what the app needs to do anyway.

That stream is basically free traffic telemetry. Every time a driver crosses a segment, Uber now knows, to the second, how long that segment just took.

Multiply that by every active driver and you get a live traffic sensor network that nobody had to install a single camera for.

Here's the catch. Live measurements only tell you what a segment did in the past few minutes.

Your ETA needs to know what it's going to do while your driver is still en route to you, which could be 15 minutes from now.

So in 2022, Uber shipped a deep learning system called **DeepETA**, and it does not just average recent history.

It refreshes these forecasts for every segment, for the next 3 hours, every few minutes, and answers roughly 2 million forecast requests a second, making it one of the busiest models running inside Uber. ([Uber Engineering: DeepETA](https://www.uber.com/us/en/blog/deepeta-how-uber-predicts-arrival-times/))

``` php
flowchart LR
    A[Driver GPS pings<br/>every 4s] --> B[Live segment<br/>crossing times]
    B --> C[DeepETA<br/>forecasts 3h ahead]
    C --> D[Routing engine sums<br/>segments on your path]
    D --> E[Correction model<br/>trained on real trips]
    E --> F[The ETA on<br/>your screen]

    classDef start fill:#e9ecef,stroke:#6c757d,color:#1a1a1a
    classDef chip   fill:#5ee6c8,stroke:#1f9c86,color:#1a1a1a
    classDef accel  fill:#9d8cff,stroke:#5b4bcc,color:#1a1a1a

    class A start
    class B,D chip
    class C,E accel
    class F start
```

And there's one more pass after all that. The routing engine's segment-summed number goes through a second model, trained on millions of completed real trips, whose only job is to catch and correct the places where the physics-based sum tends to be systematically wrong (a stop sign nobody accounted for, a left turn that always takes longer than it looks).

Shipping DeepETA improved long-trip arrival accuracy by 6%.

Uber estimates that alone is worth around $100 million a year in gross bookings, because an ETA people trust is an ETA people don't cancel on.

Next time your ETA ticks down without drama, that's 100 million road segments, a live sensor network made of other people's cars, and a model answering 2 million questions a second so a number on your screen can be boring.

Your team's attention is limited, and the deluge of AI-generated code is making it harder to keep production secure and reliable without slowing you down.

I'm building **LiveReview**, a blast-radius aware AI code review built for your business-critical systems.

Instead of presenting every diff with equal emphasis, **LiveReview scores each change by blast radius — how far its impact reaches through your call graph — so you can focus attention where it actually matters.**

Spend code review effort where business risk is highest — not spread evenly across every diff.

⭐ Star it on GitHub:

LiveReview is an AI code reviewer that scores every hunk of a diff by **blast radius**: how far a change reaches through your call graph, how much persistent state it touches, and how well-tested it is. A 3-line change to a shared auth check can outrank a 300-line UI tweak. Your team's attention goes to the highest-risk code first, not spread evenly across every diff.

*LiveReview's Blast Radius & Review Priority scoring, live in the diff viewer.*

| The exact math, not a black box | Visualize blast radius at a glance | Every factor that feeds the score | 
|---|---|---|

**Here's the goal:**

**Click below to try LiveReview with your codebase:**