The CI Pipeline Nobody Owns
Your CI pipeline is building the same Docker image three times per run, backend PRs trigger the TypeScript compiler, and a dependency bot opened 24 pull requests in two hours and ate the runner fleet for breakfast. Right now someone on your team is staring at a “runner unavailable” error, sighing and clicking re-run.
Nobody is going to fix this, and not because it is hard. Nobody is going to fix it because nobody owns it.
This post covers how a pipeline gets into this state, what it costs and the fixes (which are boring on purpose). It isn’t a post about any particular CI tool, because the tool isn’t the problem.
How a Pipeline Corrodes
Here is how it usually happens: a monorepo gets GitHub Actions and someone creates the initial workflows for a Docker build, tests and lint. It works, and then different teams add their checks: frontend adds tsc, backend adds integration tests, and infra adds a security scan.
Each addition is reasonable, and each one is reviewed by someone who understands that specific check. But nobody reviews the pipeline as a system, and nobody asks what happens when all of this runs together.
What happens is that one PR triggers 47 minutes of CI. The Docker image gets built in three jobs because nobody set up a shared build step. TypeScript runs on a PR that changed only Go and full-repo lint runs on a README fix. The runner pool runs out of capacity, so half the jobs sit in a queue before they even start.
The pipeline didn’t break. It corroded one reasonable addition at a time until the whole thing became slow, expensive and fragile.
The worst part is that it still technically works. Green checks eventually appear and PRs eventually merge. Nobody escalates it because “eventually” starts to feel like “fine.” It is not fine.
The Ownership Gap
The platform team says “We manage the runners. We do not own the workflows.” The feature teams say “We added our checks. We do not own the infrastructure.” Both are correct and both are describing the hole your CI pipeline fell into.
This isn’t a tooling problem (GitHub Actions, CircleCI, Jenkins, whatever). The gap is structural. CI sits at the intersection of infrastructure and application logic, with runners, compute and scaling on one side and what to test, lint and build on the other. No single team naturally owns both halves, so nobody owns the whole.
Systems that nobody owns optimize for addition. It is easy to add a check or a workflow or a bot, but removing things requires understanding the system, and understanding the system is nobody’s job.
So what does this cost? It costs three things:
Money. Runner spend drifts up by a few thousand dollars a month and nobody notices because nobody watches the trend. Across a year you quietly burn $40K on redundant Docker builds and unscoped linting.
Time. A PR takes 25 minutes to pass checks and 8 minutes to deploy after merge, so verification is three times longer than deployment. The fix isn’t faster runners. The fix is to stop running things that don’t apply.
Trust. This is the one that hurts. When CI is flaky, engineers stop believing it. They re-run failed jobs without reading the logs, they merge around amber checks and they build local workarounds so they don’t trigger the full pipeline. CI becomes background noise that is technically present and functionally ignored. At that point, what are you paying for?
The Dependency Bot Incident
I can picture the review that approved the dependency update bot: “It’ll keep our deps current. Automated PRs. Less toil.” Sure, good idea, except nobody set its limits to fit a shared runner pool.
So the bot opens 24 pull requests in two hours and each one triggers the full CI pipeline. Twenty-four simultaneous runs compete for the same runner pool and engineers who are trying to merge product work now sit behind automated patch bumps to logging libraries. That is a self-inflicted denial-of-service attack.
The bot did exactly what it was configured to do, so the problem wasn’t the bot. The problem was that nobody treated it as a participant in a shared system with finite resources.
The fix is boring: set concurrency limits, batch the updates and run them off-peak. But boring fixes still require an owner, because someone has to notice the problem and understand the pipeline and have the authority to change the config. When nobody owns the pipeline even boring fixes don’t happen.
The Cost of “Saving Money”
Runners scale down after business hours to save cloud spend. Reasonable.
But engineers also work late sometimes. One of them pushes at 7 PM and the job lands on a runner that starts and immediately dies (the scaling policy is mid-transition), and that engineer just lost an hour.
The runner didn’t flake. It was terminated by policy, but the error says “runner unavailable,” which tells the engineer nothing useful. So they re-run and it fails again, so they wait and try again in 20 minutes, and eventually it passes and they go home annoyed.
This happens twice a week to different people and nobody connects the dots, because there is no runner observability and no owner who tracks the pattern.
What Actually Fixes It
The fixes aren’t technically interesting and that is the point. The pipeline doesn’t need a grand rewrite. It needs attention from someone with the mandate to treat it as a system.
Scope checks to what changed. Use path-based filtering so a PR that only touches Go doesn’t run tsc and a PR that only touches docs doesn’t build Docker images. Every major CI system supports this and configuring it takes an afternoon, but the savings are permanent. On GitHub Actions, watch your required checks, because a workflow that a path filter skips leaves its required checks pending and blocks the merge.
Kill redundant builds. Build the Docker image once per pipeline run, publish it to a short-lived tag and let downstream jobs consume it. You don’t need three identical docker build steps just because three jobs each live in their own little world.
Rate-limit bots. Concurrency limits, batching and off-peak schedules are fifteen minutes of configuration and the fact that it isn’t already done tells you everything about ownership.
Make cost visible. Attribute runner spend to workflows and put it on a dashboard. The moment a team lead sees that their lint step costs $400/month, they will scope it themselves (people optimize what they can see).
Give someone the job. I don’t mean a permanent CI department. I mean one engineer for one quarter with a mandate to audit, measure and fix, and that is enough to break the “nobody owns it, so everyone suffers” loop.
The pipeline doesn’t need a team. It needs an owner.
The System Nobody Admits They Built
Your CI pipeline wasn’t designed, it accumulated. Each piece was reasonable alone and together the system is slow, expensive, flaky and unowned. The fixes are straightforward and the organizational will is the hard part.
CI pipelines are infrastructure pretending to be YAML. They feel like config that each team can manage independently, but they behave like shared distributed systems with finite resources, cross-team dependencies and real operating costs. The moment one team’s bot can starve another team’s runners, you don’t have independent workflows anymore. You have a system.
Systems without owners don’t degrade gracefully. They corrode quietly until someone asks why the cloud bill went up $40K and the answer is “nobody was looking.”
The engineering is easy, and the hard part is someone saying that this is real infrastructure, that it needs a real owner, and that the work counts.
If you have been silently re-running failed CI jobs and shrugging, you are not alone. But the shrug is the problem.