Why does your ETA keep changing when the route stays the same?

Imagine you're looking at a navigation app. 

A few minutes ago, it showed an arrival time of 17 minutes. Now it says 24 minutes. 

You zoom into the map expecting to see a different route. 

But nothing has changed. 

Same start point. 

Same destination. 

Same blue route line. 

So what exactly happened? 

If you've built applications using routing services before, you've probably assumed that a route update means calculating a brand new route. But in many cases, that's not necessary. 

In fact, one of the most common misconceptions about routing is that the route and ETA are essentially the same thing. They’re not. 

The route didn't change. Traffic did. 

When you request a route from the HERE Routing API, you're actually receiving multiple pieces of information. The API can provide route geometry, travel time information and additional route-related data as part of a route response.

One part describes where the route goes. 

Another part describes how long it is expected to take. 

Those two pieces of information are related, but they're not identical. 

A route may remain perfectly valid while traffic conditions along that route continue to change. 

As congestion builds, clears or shifts, the expected travel time can change as well. 

That means your ETA can change even when the route itself remains unchanged. 

 “Where you go isn’t the same as how long it takes to get there.” 

The traditional approach 

Many applications solve this problem by recalculating the route every time they want an updated ETA. 

The process usually looks something like this: 

• Request a route 

• Display it on the map 

• Wait a few minutes 

• Request a new route 

• Replace the old route 

• Update the ETA 

It works, but it can create unnecessary processing and visual changes. 

For users, it may even look like the route is constantly changing when all they really care about is having an accurate arrival time.  

A smarter approach 

This is where the concept of a routeHandle becomes useful. 

When calculating a route, you can request a routeHandle. This provides a way to reference the same route later rather than creating an entirely new one. 

Instead of calculating everything from scratch, you can request updated route information and receive refreshed route details. 

The result is simple: 

• The route stays the same 

• The ETA updates 

• The application avoids unnecessary route redraws 

For users, the experience feels much smoother. 

"Update route information without recalculating the entire route."

Why it matters for enterprise developers  

This pattern becomes especially useful in enterprise applications. 

Consider a fleet management dashboard tracking hundreds of vehicles. 

The dispatch team doesn’t need every vehicle’s route recalculated every few minutes. 

What they do need is an accurate understanding of when those vehicles are expected to arrive. 

The same applies to: 

• Last-mile delivery platforms 

• Logistics planning tools 

• Asset tracking solutions 

• Operations dashboards 

In many scenarios, route stability is more valuable than constantly generating new routes. 

Keeping ETAs up to date while maintaining the same route can reduce visual noise and improve operational decision-making. 

Why it matters for automotive developers  

The same principle applies inside the vehicle. 

Drivers generally prefer navigation experiences that feel stable and predictable. 

If the route line changes every time traffic conditions fluctuate slightly, the experience can quickly become distracting. 

Updating ETA information without changing the displayed route helps maintain continuity while still reflecting current traffic conditions. 

The driver gets a more accurate arrival time without the navigation system appearing to constantly reconsider its decision. 

Watch the demo 

In the accompanying video, you'll see exactly this scenario in action. 

The application: 

• Calculates a route between two locations 

• Displays route geometry on the map 

• Stores a routeHandle 

• Requests updated route information later 

• Receives a new ETA while keeping the same route 

At first glance, it looks like magic. 

Once you understand the difference between geometry and travel-time calculations, it makes perfect sense. 

It's a useful pattern to keep in mind whenever you're building navigation, tracking, logistics or fleet-management applications. 

Try it yourself 

Explore the HERE Routing API documentation and experiment with routeHandle-based route updates.