This page defines delays in ANYWAYS, their structure, behaviour, and how they interact with the routing engine.

Delays are used to slow down traffic on specific stretches of road for a scenario, without editing the underlying network.

What are delays?

Delays are a set of drawn lines with slowdowns applied on top of a network at routing time.

Delays are defined per project and consist of:

A parent network the delays are originally created on

One or more lines drawn on the map

A slowdown assigned to each line (either a maximum speed or a fixed extra delay)

Each line is:

Drawn as a polyline on the map by the user

Snapped to the network's road edges at routing time

Assigned exactly one slowdown — a max speed OR a delay in seconds, not both

Delays do not:

Alter the road network's tags or topology

Persist to any exported network data

Close, reroute, or restrict access on a road — they only affect how fast traffic can traverse the matched edges

Delays are attached per scenario. The same delays can be attached to one scenario as a "what-if" and left off another to keep it as a baseline. A delays can also be attached to a route planner network.

Delays behaviour

When a scenario (or route planner network) with delays attached is evaluated:

Every line is matched to the road edges it overlaps at the current network commit

Each matched edge picks up the slowdown from its line

Routing calculations use the reduced effective speed (or added time) on those edges

The same delays can produce different matched edges when evaluated on different network commits — line matching is re-run against the current commit each time.

When two lines from any attached delays overlap the same road edge, the slower value wins (lowest effective speed or largest extra delay).

Slowdown types

Each line carries exactly one slowdown:

Max speed (km/h)

Caps the effective speed on the matched road edges. The routing engine treats the edge as if its speed limit were the value on the line.

Use when the impact is naturally expressed as a speed: signposted speed reductions, generally slow segments, weather-driven speed caps.

Delay (seconds)

Adds a fixed penalty in seconds to the matched edges, regardless of edge length. The routing engine treats the edge as if crossing it took longer by the specified amount.

Use when the impact is naturally expressed as a wait time: traffic-light delays, level-crossing waits, unpredictable turn or junction bottlenecks.

The editor shows the equivalent value in the other unit as a placeholder so the conversion can be sanity-checked against the road's free-flow speed.

Which profiles delays apply to

Delays only affect motorised-vehicle profiles:

All car.* variants (car.fast, car.short, car.classifications, …)

All bigtruck.* variants

Bicycle and pedestrian profiles ignore delays. Their routes are computed on the underlying network as if no delays were attached.

Practical consequences:

A dataset that uses only bicycle or pedestrian profiles produces the same routes with or without delays attached to its scenario.

On the route planner, switching from car to bicycle removes the delays' effect on the calculated route, even when the same delays remain attached.

How each profile handles delays

All motorised profiles receive the same numeric slowdown, but each profile's cost model responds to it differently. Comparing routes across profiles with the same delays attached can produce visibly different paths.

`car.fast` and `bigtruck.fast`

Cost is travel time. A delay adds time in seconds and the router compares against alternatives by time saved. The most predictable behaviour — 30 s of delay costs 30 s of routing cost, regardless of where on the network it sits.

`car.short` and `bigtruck.short`

Cost is distance. The router converts the delay into extra effective distance, and the conversion scales with the road's free-flow speed. This makes the response inconsistent:

Delay on a fast road (motorway) → the edge distance is inflated heavily → the router accepts surprisingly long detours to bypass it.

Delay on a slow road (residential) → the edge distance barely changes → the delay is often tolerated even when short alternatives exist.

The reported travel time still reflects the correct added seconds; only the routing decision is speed-dependent.

`car.classifications`

Cost combines time with a preference for higher-class roads (motorway > primary > residential > service). The delay's relative penalty is smaller on higher-class roads:

Delay on a motorway → stays on it longer than car.fast would.

Delay on a lower-class road → detours to a higher-class alternative sooner than car.fast would.

Summary

Taking car.fast as the neutral reference:

car.classifications — tolerates delays on higher-class roads more than car.fast; less tolerant on lower-class roads.

car.short — opposite pattern: less tolerant on higher-class (fast) roads, more tolerant on lower-class (slow) ones.

car.fast and bigtruck.fast — cost matches driver-experienced time, no distortion.

Delays and the network

Delays are a routing-time overlay:

They do not change the network's OSM tags, edge geometry, or exported vector tiles

They are not visible to consumers of the network outside of a routing evaluation — nothing shows up in a network export or a network editor

They only affect the routing engine's cost calculation on matched edges

For permanent changes to the road — a new one-way, a closed road, a permanent speed reduction — use road network editing instead.

Relationship to other concepts

Delays are attached to scenarios and route planner networks

Delays overlay a network at routing time — they are originally created on a specific network in the project, but they can be attached to any scenario or route planner network at evaluation time

Delays affect the route planner's cost calculations on the matched edges

Delays are the routing-time counterpart to road network editing: use delays for temporary or per-scenario slowdowns, use road network editing for permanent structural changes

→ See Concepts

→ See Road network

→ See Scenarios and Simulation Behaviour

Delays