The Network Automation 'Messy Middle': Why Most Teams Get Stuck, And What Actually Gets Them Out
Conxiea
16 May 2026
→ See How Conxiea Helps Teams Move Beyond the Automation Middle Ground
There's a pattern that comes up in almost every network automation discussion, and it's rarely talked about honestly.
The conversation goes from "we have a few scripts" straight to "full NetBox / Ansible / pipelines / GitOps setup." As if the path between those two points is a decision rather than a years-long slog through ambiguity, technical debt, and organisational friction.
It isn't. And the jump in the narrative skips over the place where most teams actually live: somewhere awkwardly in the middle. Some automation. Some manual work. Different tools that mostly don't talk to each other. Documentation that's half there. Engineers who know what needs doing but can't justify the time to do it properly, so they patch it instead.
This post is about that middle stage, what it actually looks like, why it exists, what keeps teams stuck in it, and what genuinely moves them out.
Network engineer surrounded by tangled, messy cables in a cluttered server room
What the Messy Middle Actually Looks Like
If your environment is in the messy middle, it probably looks something like this.
Scripts that work, if you know how to run them. One or two engineers wrote Ansible playbooks or Python scripts for the things that were genuinely painful. They work, mostly. But they live on someone's laptop or a shared drive with a naming convention only the author understands. Running them requires tribal knowledge. Other engineers don't touch them.
Automation coverage that stopped growing. You automated the obvious stuff, config backups, maybe some VLAN provisioning, some compliance checks. But the list of things you want to automate is much longer than the list of things you actually have automated. And that gap hasn't closed in a while.
Manual work that crept back in. The automation worked, but then the environment changed and the playbook didn't get updated. Or someone made a manual change that the automation didn't account for. The team learned to work around the automation rather than through it. The manual habit reformed.
Tools that don't connect. Your monitoring platform doesn't feed your ticketing system. Your change management process doesn't touch your automation tooling. NetBox has half the data about your network; the other half lives in a spreadsheet. Everything requires manual handoffs between systems.
One engineer holding it together. There's usually one person who built most of the automation and genuinely understands it. They've become a single point of failure. When they're on holiday, automation-related problems go unresolved. When they leave, the institutional knowledge leaves with them.
"Usually it's one or two people maintaining a pile of scripts nobody else wants to touch, Ansible playbooks that half work, and everyone still doing stuff manually because the automation is too much of a pain to update.", Network engineer, r/networking
This description resonates so widely because it's accurate. And the remarkable thing is that most of the teams in this position are aware of it. The problem isn't a lack of knowledge about what good looks like. It's the gap between knowing and being able to get there.
Why the Messy Middle Exists
The messy middle isn't a failure state. It's a predictable consequence of how automation actually develops in real organisations.
Automation starts as a personal project
The first network automation in most organisations was written by one engineer who was tired of doing the same thing manually. They solved their problem. They didn't design for the team.
Scripts written to scratch a personal itch are typically not documented, not version-controlled, not tested for other people's environments, and not designed to be handed over. They work for the person who wrote them. They're fragile for everyone else.
This isn't a criticism, it's a starting point. The problem is when this phase never transitions into something deliberately designed for the team rather than the individual.
The tools get adopted before the processes change
Teams discover Ansible, deploy it, write some playbooks, and declare automation in progress. But the organisational processes around change management, testing, approval, and documentation don't change. The automation runs alongside the manual process rather than replacing it. Engineers use the playbook when it's convenient and bypass it when it isn't.
Automation that doesn't own the process end-to-end will always have manual work creeping back in around the edges.
The culture change is harder than the technology
"A lot of people go to Ansible at this point. Unfortunately, they recognise how hard it is going to be to change the culture, to set up the scripting, to change the processes to require it, etc. and they get stuck with a half-complete, mostly unused solution. This seems to be where most network automation goes to die.", Network engineer, r/networking
That's blunt. It's also accurate.
Automation requires the team to trust it, to run the playbook rather than logging into the device manually, even for changes where manual feels safer. Building that trust requires automation that is demonstrably reliable, well-documented, and explainable. Getting to that standard requires engineering investment that's hard to justify when the manual process works well enough.
This is the circular trap of the messy middle: the automation isn't reliable enough to be trusted, it isn't trusted enough to be used, and it isn't used enough to be improved.
The maintenance burden grows faster than the team
Playbooks go stale as environments change. Scripts break when device software versions update. Documentation lags behind the actual state of the tooling. The engineer who built the automation is now spending half their time maintaining it rather than extending it.
At some point, keeping the existing automation working consumes most of the bandwidth that should be going toward improving it. Progress stalls.
For a detailed breakdown of where Ansible specifically hits this ceiling: Ansible vs. Enterprise Network Automation Software: When to Move On
The Three Paths Out of the Messy Middle
Teams that genuinely move beyond the messy middle do it in one of three ways. All of them require deliberate action, the messy middle doesn't resolve itself.
Path 1: Invest seriously in conventional automation maturity
This is the long road. It means treating automation as a first-class engineering discipline, with version control, testing, documentation, peer review, and a shared ownership model rather than one person's side project.
It typically requires:
- Migrating scripts and playbooks into a shared, version-controlled repository (Git) with consistent structure and documentation standards
- Building a testing framework, ideally with a lab environment for validating playbooks before production deployment
- Wrapping automation in change management workflows, approval gates, audit trails, rollback procedures, so it can be trusted for production changes
- Establishing team coding standards so automation can be maintained by anyone, not just its author
- Integrating automation tooling with your ITSM (ServiceNow, Jira) and monitoring platforms so it's part of the operational workflow, not adjacent to it
This path works. It's how the most mature network automation environments are built. It also requires sustained organisational commitment, typically 12–24 months of deliberate investment before the environment is genuinely stable and the messy middle is behind you.
For what this commitment actually involves step by step: Network Operations Automation Roadmap: How to Build It Without Starting Over
Path 2: An external forcing function
The teams that progress fastest through the messy middle often don't do it because they chose to. They do it because something external forced the pace.
An audit finding that requires complete change documentation. A major incident attributed to manual process failure that creates executive pressure to fix the automation programme. A new CTO from a DevOps background who makes it non-negotiable. A regulatory requirement with a compliance deadline.
External forcing functions bypass the circular trap, they create organisational justification for the investment that the team couldn't build bottom-up. If you're in the messy middle and you can see a forcing function on the horizon, start the work now so you're not firefighting when it arrives.
For the business case to take to leadership: The Real ROI of Network Automation for Enterprises
Path 3: Layer AI on top of what you have
This is the path that wasn't available five years ago, and it's the one most relevant to the current state of the market.
The logic of Path 1 assumes you need to fix the messy middle before you can move beyond it. AI-driven network automation platforms invert that assumption. Instead of requiring you to build a clean, unified automation foundation before AI can sit on top of it, they sit above your existing tooling, integrating with what you have, not requiring you to replace it.
Where conventional automation executes what you've predefined, an AI platform reasons about your environment. It correlates events across your monitoring data, ITSM, change history, and device state. It identifies root cause rather than just matching patterns to playbooks. It generates environment-specific actions rather than applying templates. And it does this regardless of whether your underlying tooling is a mature GitOps pipeline or a pile of scripts from 2019.
This matters for teams in the messy middle because the biggest operational pain points, slow troubleshooting, alert noise, change-related incidents, manual diagnostic work, are the ones AI addresses most directly. You don't have to finish the modernisation project to get operational improvement. You get the improvement while the modernisation continues in parallel.
For what this actually looks like in practice: You've Got Network Automation Tools. So Why Is Your Team Still Firefighting?
What Moves the Needle (and What Doesn't)
After working with infrastructure teams across a range of automation maturity levels, the patterns are consistent.
What doesn't move the needle:
- Buying more tools without changing the ownership model, new tools become part of the disconnected pile
- Automating the easy things and stopping, quick wins that aren't followed up don't build momentum
- Treating automation as a one-person project, if one engineer owns it, it stays fragile
- Waiting for the perfect foundation, the environment keeps changing and the perfect foundation never arrives
What does:
- Making automation the required path for routine changes, not the optional one, this is the single cultural change with the highest impact
- Getting shared ownership across the team, code reviews, shared repositories, rotation of maintenance responsibility
- Measuring outcomes, not activity, track MTTR, change failure rate, manual task volume, not "playbooks written"
- Starting with the operations that cause the most pain, high-volume, high-friction tasks where the improvement is immediately visible
For a prioritisation framework to identify where to start: What Network Operations Should You Automate First?
The Honest Assessment
The messy middle is real, it's where most teams are, and it's harder to escape than the industry narrative suggests. The journey from "a few scripts" to "mature automation platform" isn't a smooth progression, it's a series of difficult decisions about culture, process, and investment that most organisations approach reactively rather than proactively.
But the messy middle isn't permanent. Teams do get out of it. The ones that do share a common trait: they stopped treating automation as a background project and started treating it as a core operational capability that deserves the same engineering rigour as the network itself.
Whether that means investing seriously in conventional automation maturity, waiting for an external forcing function, or layering AI above the existing tooling while the foundation improves, the path forward is different for every environment.
What's consistent: the middle doesn't resolve itself.
Stuck in the network automation middle ground, and not sure what the most direct path out looks like for your environment?
At Conxiea, we work with infrastructure teams at every stage of automation maturity. Whether you need a realistic assessment of where your current programme is and how to move it forward, or you want to understand what an AI operational layer would change without requiring you to fix everything else first:
No agenda. An honest conversation about where the gaps are and what would actually help.
Related Reading
- You've Got Network Automation Tools. So Why Is Your Team Still Firefighting?
- Ansible vs. Enterprise Network Automation Software: When to Move On
- What Network Operations Should You Automate First?
- Network Operations Automation Roadmap: How to Build It Without Starting Over
- Why Network Automation Fails in Most Businesses
- The Real ROI of Network Automation for Enterprises
- 5 Signs Your Enterprise Has Outgrown Manual Network Operations