As organizations reimagine how they connect people, applications, and data, one theme keeps resurfacing: agility. One of the most transformative ways this is being realized is via programmability and automation.
This article is the final in a three-part series, exploring the trends reshaping networking. In part one, we unpacked the rise of cloud-native networking, where service meshes, APIs, and open standards are reshaping connectivity.
Part one of this series explored the rise of cloud-native networking, where service meshes, APIs, and open standards are reshaping how enterprises build and scale distributed applications. In Part two, we examined secure by design principles, with a zero trust approach, secure access service edge (SASE), and quantum-safe planning becoming non-negotiable foundations for the next decade.
Automation is another pivotal strand to the change that’s taking place. Instead of relying on manual command-line interfaces (CLI), tomorrow’s networks will be defined by code, workflows, and application programming interfaces (APIs). From infrastructure as code (IaC) and observability to evolving NetOps skillsets, automation is not just about efficiency – it is becoming the DNA of modern networking.
Infrastructure as code is redefining how networks are built
Infrastructure as code has long been a staple in cloud computing but its adoption in networking is still maturing. Patricio Martelo, director of network solution architecture at Alcatel-Lucent Enterprise, says that while “IaC for networks is maturing at a rapid pace, it is not widely adopted outside of cloud environments”. He explains that networks don’t always have the same dynamic, on-demand nature as cloud workloads, so many organizations selectively adopt IaC in provisioning, compliance auditing, or remediation, but not yet in continuous operations.
The barriers are clear: skills gaps, legacy systems, and a lingering mindset shift. Hommer Zhao, director at Wiringo, emphasizes that trust is the biggest hurdle. “In the cloud, infrastructure as code is standard but in networking, many teams still rely on old systems and manual processes. The biggest hurdle is trust; people worry about giving too much control to code when downtime can cost millions,” he says.
Still, the risks of not adopting automation may be even greater. Sam Measures, head of domain Architecture at Markerstudy Insurance Services, explained that IaC unlocks agility when combined with guardrails such as pre-release code scanning. “The key to risk mitigation is to perform pre-release code scanning, deploy to non-production environments first, and leverage blue/green deployments,” he says.
The message is that enterprises cannot afford to treat networks differently from the rest of IT. As Zhao put it, agility without control is dangerous, but speed with safety nets like testing, rollback, and validation creates resilience, not fragility.
Observability is moving from visibility to intelligence
If automation is the engine of modern networking, observability is its navigation system. Traditional monitoring shows what is happening; modern observability aims to explain why – and increasingly, what to do next.
Martelo says observability must evolve to become advisory: “Tools must go beyond the current network status and help keep the network running optimally and securely both today and tomorrow.” He points to security scorecards, compliance benchmarks, and even automated remediation as the next frontier.
Zhao agrees, telling ITPro that most businesses today don’t just want raw data; they want actionable guidance. “Right now, most tools tell you what’s happening. What businesses really need are tools that suggest what to do about it,” he explains.
The role of real-time telemetry is also central here. As Measures explained, telemetry allows engineers to validate whether automated changes are still allowing traffic to flow as intended. But the challenge is the flood of raw data. “Telemetry is like a health check for the network. The challenge today is that we get too much raw data and not enough clear signals,” Zhao emphasizes.
To make telemetry useful, enterprises must invest in standardization. Formats like YANG and OpenTelemetry are gaining traction, helping unify fragmented data streams and turning noise into insight.
NetOps skills are shifting from CLI to coding
One of the most significant implications of programmability and automation is cultural. Traditional network engineers – long masters of the CLI – are being asked to think and work like software developers.
Martelo says resistance is still strong: “A large portion of network engineers still resist automation and only trust the CLI, which in many cases is due to fear of losing control.” His advice is pragmatic: start small. “The first step is learning how to code, preferably in Python. Once you understand one programming language, you can understand any piece of code or script if you look at it long enough.”
From there, engineers can build toolkits around Git, APIs, and orchestration platforms like Ansible or Terraform. Zhao puts it more simply: “Networking pros need to get comfortable with coding basics. You don’t need to be a full software developer, but knowing how to use APIs, automation scripts, and version control is becoming essential. It’s about thinking in workflows, not just commands.”
Measures emphasized that understanding DevOps methodologies and CI/CD delivery models is just as important as coding. “Network engineers need to focus on understanding the fundamental principles of DevOps methodologies. They need this foundation to properly embrace Infrastructure-as-Code,” he says.
Even certifications will need to adapt, as Zhao tells ITPro:
“Certifications will have to change. They’ll still cover the basics of how networks run, but they’ll also include automation, cloud integration, and coding. It’s less about memorizing commands and more about proving you can design and manage networks in a smarter way.”
The road ahead: balancing standards, ecosystems, and lock-in
As programmability becomes mainstream, the question remains: will the industry converge on open standards, or fragment into vendor-specific ecosystems?
“Customers who prefer a best-of-breed approach or want to protect themselves from vendor lock-in will demand open standards,” says Martelo who sees both forces at play. “But vendors will innovate above and beyond the open standards to create a differentiated value proposition.”
Measures, however, is more skeptical, suggesting that abstraction languages like Terraform may be the only way to achieve true interoperability across ecosystems. Without them, enterprises risk being pulled deeper into proprietary silos.
Zhao is blunt: “The hardest part is consistency. Each cloud provider has its own way of doing things, so when a company uses several clouds, it ends up juggling different tools and policies. Without common standards, automation risks becoming patchwork.”
The reality is that hybrid and multi-cloud networking will remain complex. Unifying observability and automation across diverse environments require trade-offs: either accept vendor lock-in for simplicity or pursue open standards with the added burden of managing complexity.
Programmable networks as the new baseline
Across this three-part series, we’ve seen a consistent theme: the future of networking is cloud-native, secure by design, and programmable. Cloud-native networking gave us agility, APIs, and service meshes. Secure networking established zero trust and SASE as baselines. And now, programmability and automation (Part 3) are redefining how networks are built, observed, and operated.
As Zhao explained, programmability is not about replacing humans with code. It is about giving humans the confidence, safety nets, and intelligence to run networks at the speed of business. Or as Martelo tells ITPro, the future is one where “code, not command lines, defines how infrastructure is built and managed.”
For business leaders, the implications are profound. Networks are no longer static infrastructure; they are dynamic, software-defined systems that demand new tools, new mindsets, and new skillsets. The organizations that embrace Infrastructure-as-Code, invest in observability, and retrain their NetOps teams for automation will not just survive the next decade—they will thrive.
