There used to be a person who knew the network, who was an artisan and for a long time the work around networks genuinely demanded artisanship. A network was a physical thing assembled for physical boxes, each configured through its own command line dialect, each subtly different from its neighbor. Expertise meant memorizing those dialects and developing an intuition for where the bodies were buried. It was skilled, valuable work. It was also completely unable to keep up with what came next.
The pressure on the previous model made it untenable. We could not scale tens of thousands of devices (physical or virtual constructs) by manually touching each and every one of them throughout their lifecycle, and the moment a “device” might live for ninety seconds before vanishing, the console cable becomes a relic. You cannot log in to something that no longer exists. The cloud finished the job when it redefined what a network even is, not a rack you can point at, but a set of abstractions you summon with an API call. And the applications riding on top stopped shipping in quarterly events and started shipping several times before lunch, leaving no room for a human to approve every change in the path. Scale, ephemerality, and pace all pushed in the same direction, and the artisan’s model had nowhere left to stand.
So the work changed in one decisive way, we stopped telling the network what to do and started telling it what to be. The artisan issued commands, just a sequence of instructions typed into a box. The modern approach declares a desired state, these networks should exist, this traffic is allowed, these routes are advertised, and a system works out how to make reality match. It sounds like a small semantic shift. It is the whole revolution. Because a description of desired state is just text, and text goes in a file, and a file goes in version control alongside the application code, and at that exact moment the network inherits everything software engineering spent decades learning.
It inherits history, where every change is recorded, attributed, and revertible. It inherits review, a second engineer reading a change before it touches anything real. It inherits testing and continuous integration that can validate a configuration, even stand up a virtual replica of the topology, before a single packet is affected. It inherits pipelines that apply changes automatically and roll them back when the signals look wrong. The 2 am fix stops being an act of heroic memory and becomes a pull request. The network is no longer a fragile thing one person understands, it is a body of code a team can reason about together.
This is where network design and software design quietly became the same discipline. A modern system holds two pictures at once, the desired state you declared and the observed state that is actually true, and runs a controller whose only job is to notice the gap and close it, continuously, without being asked. That reconciliation loop is the engine inside Kubernetes, working a cluster toward its manifests. It is the engine inside the tools that provision cloud infrastructure from declarative definitions. And it is exactly how software defined networking works, a controller programming the fabric to match intent and healing around failures as they appear. Three different layers, one identical shape. The engineer who understands the pattern in one understands it in all of them, and that transfer, not any single tool, is the real story of the modern era.
The line between “the network” and “the application” is dissolving as a result. Service meshes lift routing and traffic policy up into software that travels with the code. APIs have replaced the console cable, so an application can reshape its own connectivity at runtime as casually as it allocates memory. There is no longer a network team throwing configs over a wall to an applications team; there is one system, expressed in code, observed through shared telemetry, operated by people fluent across the layers.
None of which makes the old knowledge worthless, you cannot simply automate what you do not understand, and a clean abstraction over a system you cannot reason about is only a faster way to cause an outage. But that knowledge now lives in code and in systems thinking rather than in muscle memory and a console session. The destination is a network that disappears, not because it stopped mattering, but because it finally became programmable and self-healing enough to recede into the background, the way all good infrastructure eventually should. We spent decades unable to look away from the network. We are finally building the kind we can trust to look after itself.