A software company in Bosnia just posted a vacancy for a mid-senior DevOps Engineer. The responsibilities read like a confession: design infrastructure as code, build CI/CD pipelines, automate deployments, manage monitoring and alerting, handle secrets, containerize things, tune databases, write runbooks, sit in meetings about "scalability, cost, and operability." Every single item on that list is a task whose entire purpose is to remove humans from a process. The role is a professional human-eliminator — and the industry has been very busy figuring out how to eliminate this particular human too.
What the role actually is
Strip away the buzzwords and a DevOps Engineer at a product company does maybe six things.
- Writes Terraform describing cloud infrastructure.
- Writes YAML describing pipelines: build, test, scan, deploy.
- Wires up monitoring, logging, and alerts, then tunes them until 3 a.m. pages stop being noise.
- Handles database operational chores — migrations, backups, the occasional panic about disk space.
- Debugs whatever broke in staging that "works on my machine."
- Explains all of the above to developers, security people, and product managers, in sentences, sometimes with diagrams.
That last one is supposedly the moat. "Excellent communication is as important as technical depth," says the posting. We will come back to that moat. Moats have a way of being drainage ditches.
The replacement, piece by piece
Infrastructure as code. This is the easiest one, ironically, because it is already code — declarative, pattern-heavy, endlessly repetitive. An AI agent given read access to an existing cloud account can inventory every resource, reverse-engineer the current state into Terraform modules, and produce cleaner HCL than the last contractor left behind. The prompt is not even exotic: "Here is the AWS console state, here are our tagging conventions, produce modules with sensible defaults and a plan file." The hard part of IaC was never typing. It was knowing what to build. But at a company this size, the architecture is a handful of VPCs, some managed databases, a Kubernetes cluster, and a queue. That is a solved shape. Agents handle solved shapes.
CI/CD pipelines. A pipeline file is a config artifact with strong conventions and immediate feedback — the exact profile where AI shines. The agent reads the repo, detects the stack, emits a pipeline with build, unit tests, linting, SAST scanning, artifact signing, and a staged rollout. When the pipeline breaks — and pipelines break constantly — the agent reads the logs, identifies the flaky test or the expired credential or the cache miss, and opens a PR fixing it. This loop is already running in the wild at companies that stopped pretending a human needs to shepherd YAML.
Monitoring and alerting. The ugly secret of observability is that most of it is threshold-fiddling and alert-triage. The agent ingests dashboards and historical incidents, proposes SLOs, wires alert routing, and — the good part — becomes the first responder. At 3 a.m., the agent gets paged instead of a human. It correlates the alert with recent deploys, checks whether the metric blip matches a known pattern in the incident history, and either auto-remediates (restart the pod, scale the deployment, clear the queue) or writes a structured incident summary for the morning. The human reads it with coffee. Incident auto-triage and summarization is where the tooling money is flowing right now.
Database chores. Migrations are scripts. Backups are schedules. Performance tuning is reading slow-query logs and adding indexes — a task with such a canonical shape that it is practically a benchmark. The agent drafts migrations alongside schema PRs, runs them against a shadow copy, watches the query plans, and only pages a human when the plan involves the words "locking" and "production" in the same sentence.
The debugging. "Troubleshoot and resolve infrastructure issues across environments and communicate root causes clearly." An agent with access to logs, traces, deploy history, and the runbooks (which, note, this role is also hired to write) can do the correlation faster than a tired engineer. And the "communicate root causes" part? Drafting a clear post-incident explanation is a language model's home turf. The runbook-to-remediation pipeline closes itself: the human writes runbooks so a machine can execute them, and the machine reads incident after incident until it writes its own runbooks better.
The internal tools and scripts. The posting asks for "internal tools, automation scripts, and supporting backend services." These are small, well-scoped codebases with obvious specs — the exact category of software AI now writes unassisted. A CLI that rotates a credential, a service that syncs environments, a webhook handler. The agent does not need the org chart to build these. It needs a ticket.
The pipeline that replaces the pipeline-builder
Assembled honestly, the replacement looks like this:
- A repo-scanning agent that maintains IaC and pipeline configs as living artifacts, opening PRs whenever drift appears or a dependency needs bumping.
- A guardian agent that watches deploys, ingests telemetry, executes remediation playbooks, and escalates with evidence attached.
- A cost agent that reads the cloud bill, flags the idle load balancer and the over-provisioned database, and files the change itself.
- A scribe agent that turns every incident, every change, every meeting note into updated runbooks and documentation — the documentation task that humans famously never do, done continuously by a machine that never gets bored.
One on-call human supervises the fleet of agents. Maybe.
Where it breaks
Now the catch, because there is one, and pretending otherwise is how you spot a sales pitch.
The novel incident. When the system fails in a way it has never failed before — a cloud provider's regional outage cascading through a poorly-understood dependency, a Kubernetes upgrade that breaks a legacy workload in a way nobody documented — the agent's pattern library runs dry. It can gather evidence, but the leap from "here are the symptoms" to "the actual cause is this interaction nobody anticipated" is still human territory. For a while.
The blame sink. Companies need someone to be accountable. When production burns, an organization wants a throat to choke and a person to stand in the incident channel saying "I'm on it." An agent saying "I'm on it" satisfies nobody, and the org chart knows it. Expect the job title to survive long after the work is automated — a human "responsible for the AI that does the DevOps," which is this role's likely next posting.
The trust ramp. Nobody flips a switch and hands production credentials to an agent. The realistic path is the agent proposing, the human approving, for a year or two. During that window, the engineer is not gone. They are a click-approver with a pager. Whether that is a promotion or a demotion depends on your tolerance for watching someone else's homework.
And the communication moat. The posting insists communication matters as much as depth. Here is the uncomfortable observation: most of that communication is translation — turning infra reality into sentences product managers can act on. Translation between domains is, of course, the single most automated skill of this entire decade. The moat was a translation service all along.
The verdict
The DevOps Engineer was hired to automate everyone else's toil, and the toil came for them with the same tools they wielded. There is a symmetry there that is almost poetic, if poetry involved IAM policies.
The Bosnian company will hire their engineer. The engineer will do good work for two or three years, and much of that work will be building the automation scaffolding that makes the next engineer optional. That is not cynicism. It is literally the job description they posted.
So here is the dare, for whoever takes the role: on day one, look at your pipeline config, your Terraform, your alert rules, your runbooks, and ask which of them a machine could have written. Then ask which of them a machine will write, the moment someone with budget gets curious.
You already know the answer. You were hired to build it.

