A static route keeps doing exactly what it was told, forever — even after the path it points to is dead. A dynamic routing protocol is built to notice that and do something about it. That difference is the entire tradeoff.
A static route is a routing table entry an engineer typed in by hand: "to reach network X, send traffic out this interface, to this next hop." It never changes on its own. It doesn't matter whether the link it depends on is up, down, congested, or has been unplugged and hauled off to another building — the router keeps forwarding traffic to that next hop because that's literally the only instruction it has. A dynamic routing protocol— OSPF, BGP, EIGRP, and others — is the opposite kind of thing entirely: routers running it continuously discover their neighbors, exchange reachability information about the networks they can see, and recalculate the best path whenever that information changes. When a link fails, routers running a dynamic protocol notice within seconds (or less) and recompute a path around the failure automatically, with no human involved. Neither approach is a lesser version of the other — they solve the "how does a router decide where to send this packet" problem in two genuinely different ways, and the right one to use depends entirely on what the network actually looks like.
A static routecosts almost nothing to run. There's no protocol overhead, no periodic updates crossing the wire, no CPU spent recalculating anything, and no ambiguity about what the router will do — it is completely predictable. The tradeoff is that it is also completely inert: if the topology it was designed for changes — a link fails, a device moves, a new subnet gets added — the static route has no way to know that. It will keep pointing at the same next hop it was configured with until a human notices the problem and edits the configuration by hand.
A dynamic routing protocol trades that simplicity for adaptability. Routers running OSPF, for example, form adjacencies with their neighbors, flood link-state advertisements describing what they can reach, and run an algorithm to compute the best path to every known network — then redo all of that the moment anything changes. That buys automatic failover: lose a link, and traffic reroutes around it without anyone touching a keyboard. It also buys real costs that a static route never has to pay: control-plane CPU and bandwidth spent on neighbor discovery and updates, meaningfully more complex configuration and troubleshooting, and failure modes that only exist because the protocol is dynamic in the first place — routing loops during inconsistent states, and a convergence delay between when a failure happens and when every router agrees on the new path.
Put a dynamic routing protocol on the exact same topology and the outcome changes completely. Routers running OSPF maintain an adjacency with each neighbor via periodic hello packets — when Link 1 goes down, Router A and Router B stop hearing from each other almost immediately, and each floods a link-state advertisement telling every other router in the area "this path is gone." Every router recalculates its shortest-path tree with that information removed, and Router A installs Router C — over the still-healthy Link 2 — as the new next hop to the destination network. No engineer has to notice the outage, log in, or type anything. The tradeoff for that automatic recovery is everything static routing skips: the hello traffic and recalculation happen continuously whether anything is failing or not, the router has more configuration and protocol state to get wrong, and there's a real convergence window — anywhere from under a second to tens of seconds depending on the protocol and topology — during which different routers can briefly disagree about the topology, which is exactly the condition that produces a temporary routing loop.
A static route is a single fact, checked never. That makes it essentially free to run and impossible to get wrong once it's configured correctly — but it also means it can never respond to anything, because nothing about it is designed to. A dynamic routing protocol is a continuous, standing process: routers are constantly listening for neighbors, constantly willing to re-derive the entire routing table from scratch the moment new information arrives. That's what buys automatic failover — but that same continuous process is what costs CPU cycles and bandwidth on hello and update traffic whether or not anything is failing, adds real configuration surface area (areas, metrics, authentication, redistribution) that has to be gotten right, and opens the door to problems that simply cannot happen with a static route at all — transient routing loops while routers hold inconsistent views of the topology, and a convergence delay between the moment of failure and the moment every router agrees on the fix. Neither cost structure is wrong; they're just the price of two different capabilities.
False — static routes aren't a legacy stand-in for dynamic routing, they're the deliberately correct choice for a specific and extremely common kind of network: small, stable, and single-path. Consider a stub network — a branch office or a small site with exactly one connection out to the rest of the world, such as one link to a single ISP. There is, by definition, no alternate path for a dynamic protocol to discover or converge onto — if that one link goes down, every routing protocol in existence is equally unable to route around it, because there is nowhere else to route the traffic to. In that situation, a static default route (0.0.0.0/0 pointing at the ISP) delivers the identical outcome a dynamic protocol would, with zero configuration complexity, zero protocol overhead, zero attack surface from a routing protocol that could be exploited, and zero risk of a routing loop or slow convergence — because there was never any redundancy for those problems to apply to in the first place. Dynamic routing earns its cost by exploiting real topological redundancy; where that redundancy doesn't exist, the cost buys nothing and the static route is the better engineering decision, not the outdated one. The right call is topology-driven, not a matter of one approach being categorically more modern than the other.
Explains the fundamental difference between a static route (a manually configured routing table entry that never changes on its own, even after the path it points to fails) and a dynamic routing protocol such as OSPF, BGP, or EIGRP (which continuously discovers neighbors, exchanges reachability information, and automatically recalculates paths — including routing around a failed link) — and clarifies when each is the correct engineering choice.
A static route is a routing table entry an engineer types in directly: a destination network, and the next hop or exit interface to reach it. It requires no protocol, no neighbor relationship, and no ongoing CPU cost — it simply sits in the routing table until someone edits it. Its defining limitation is that it has no mechanism to detect that anything has changed. If the link or next hop it depends on fails, the static route keeps pointing at it regardless, and traffic sent along that route is dropped ("black-holed") until a human notices and reconfigures it.
A dynamic routing protocol — OSPF, EIGRP, and BGP are the most common examples — has routers actively form adjacencies with their neighbors, exchange information about the networks they can reach, and run an algorithm to compute the best path to every destination. When a monitored link or neighbor becomes unreachable, routers detect that within a short window (via missed hello packets or a similar keepalive mechanism), propagate the change to other routers, and recalculate routing tables so traffic is automatically forwarded over a surviving alternate path — with no manual intervention.
Dynamic routing's ability to reroute around a failure isn't free. Routers running a dynamic protocol continuously spend CPU and bandwidth on neighbor discovery and update traffic, whether or not anything is failing. Configuration and troubleshooting are meaningfully more complex — areas, metrics, redistribution, and authentication all become variables. And the protocol introduces failure modes that a static route structurally cannot have: transient routing loops while different routers briefly hold inconsistent views of the topology, and a convergence delay — the time between a failure occurring and every router agreeing on the corrected path — during which reachability can be degraded.
Static routing is the right call whenever a network is small, stable, and has no real path redundancy to exploit — most commonly a stub network with exactly one connection to the rest of the world, such as a branch office with a single ISP uplink, configured with a static default route. Because there is no alternate path in that topology, a dynamic routing protocol cannot route around a failure of that single link any better than a static route can — there's nowhere else to send the traffic. In that scenario, dynamic routing's overhead, complexity, and failure modes buy nothing, while a static route delivers the identical practical outcome for zero cost. The decision is driven by whether real topological redundancy exists to exploit, not by which approach is newer.
Not on its own. A static route only reroutes automatically if an engineer has specifically configured a floating static route — a second static route to the same destination with a worse administrative distance, which only gets installed in the routing table if the primary route is withdrawn. Without that extra configuration, a plain static route has no failover behavior at all; it keeps pointing at the same next hop regardless of its actual reachability.
Because dynamic routing's extra capability comes with extra cost: continuous protocol overhead, more configuration to get right, and failure modes (routing loops, convergence delay) that a static route cannot experience. On a small, stable, single-path network — where there's no alternate path for a protocol to converge onto anyway — that extra cost buys nothing, so the simpler, zero-overhead static route is the better engineering decision, not a compromise.
Convergence is the state where every router in the network agrees on the current best path to every destination. After a topology change, it takes a nonzero amount of time — from under a second to tens of seconds, depending on the protocol and network size — for the change to be detected, propagated to all routers, and for each router to recalculate its paths. Until convergence completes, different routers can briefly hold different views of the topology, which is the condition that produces a temporary routing loop.
Yes, and it's extremely common. A typical design uses a dynamic protocol like OSPF across the redundant core of a network, where automatic failover has real paths to exploit, while using static routes at the edges — such as a default route out to an ISP, or a route to a small stub site with one uplink — where no redundancy exists for a dynamic protocol to use. Administrative distance determines which route wins if both a static and a dynamically learned route exist for the same destination.
A routing loop happens when two or more routers each believe the other is the best path to a destination, typically because they hold inconsistent, not-yet-converged views of the topology after a change — traffic bounces between them until it's dropped or the routers converge. A static route can't produce this on its own because it's a single fixed instruction with no dependency on what other routers currently believe; there's no shared, changing state for two static routes to disagree about.
Try our Enterprise IT Networks Studio
More calculators, simulators, and guides for this discipline.