DevOps Bullshit: A Field Guide for the Modern Engineer
There was a time when software development was simple.
You wrote code. You deployed code. The code crashed in production. You fixed it. Everybody went home.
Then we (they) invented DevOps.
Or rather, we invented talking about DevOps.
Today, it’s entirely possible to spend six months building a “cloud-native, GitOps-enabled, AI-assisted platform engineering ecosystem” without actually shipping anything useful.
Welcome to DevOps.
Everything Is a Platform
One of the first signs you’ve entered advanced DevOps territory is when someone says:
“We should build an internal platform.”
Nobody knows what this means.
It usually starts with a small problem:
“We need a better deployment process.”
Three months later, a team of seven engineers is designing a Kubernetes abstraction layer that abstracts another abstraction layer which itself exists only to avoid editing YAML files.
The result is a platform so sophisticated that nobody can deploy anything without attending three workshops and reading forty pages of documentation.
But at least it’s scalable.
YAML All the Way Down
DevOps has a unique ability to turn straightforward tasks into archaeological expeditions through configuration files.
Need to expose a web service?
Excellent.
First, update the Helm chart values.
Then modify the Terraform module.
Then adjust the ArgoCD application.
Then update the GitHub Action.
Then fix the secret management configuration.
Then discover that one of those changes was overwritten by another automation system that nobody remembers installing.
The actual application code remains untouched.
Progress.
The Sacred Kubernetes Ritual
Kubernetes is undoubtedly one of the greatest engineering achievements of the modern era.
It’s also responsible for approximately 73% of all DevOps conference talks.
Every problem somehow leads back to Kubernetes.
Need to host a simple API?
Kubernetes.
Need a cron job?
Kubernetes.
Need to print a PDF once a week?
Believe it or not, Kubernetes.
At some point, engineers started treating containers the way medieval alchemists treated mercury: nobody fully understood it, but everyone agreed more of it was probably better.
Observability: Watching Systems Fail in High Definition
In the old days, applications crashed and you had no idea why.
Today, applications crash and you have dashboards, traces, logs, metrics, heatmaps, alerts, anomaly detection, and AI-generated incident summaries explaining exactly how they crashed.
This is called progress.
Modern observability doesn’t necessarily prevent outages. It simply ensures that everyone can admire them in real time.
CI/CD Pipelines That Require a Pilot License
The original idea was beautiful.
Commit code.
Run tests.
Deploy automatically.
Simple.
A decade later, many pipelines resemble international airport control systems.
There are build stages, validation stages, security stages, compliance stages, quality gates, deployment gates, approval gates, rollback gates, and occasionally a gate whose purpose nobody remembers.
The actual deployment takes thirty seconds.
The pipeline takes forty-five minutes.
AI Will Solve Everything
No modern DevOps discussion is complete without AI.
Every vendor promises that AI will eliminate outages, optimize infrastructure, write Terraform, generate runbooks, manage incidents, predict failures, and possibly fix your marriage.
In practice, AI currently excels at generating Kubernetes manifests that look convincing enough to cause serious damage.
But the demos are excellent.
The Infinite Toolchain
A fascinating property of DevOps is that every tool eventually requires another tool to manage it.
You need Terraform.
To manage Terraform you need Terragrunt.
To manage secrets you need Vault.
To manage Vault you need operators.
To manage operators you need Kubernetes.
To manage Kubernetes you need platform engineers.
To manage platform engineers you need meetings.
The circle of life continues.
The Real DevOps
Underneath all the buzzwords, dashboards, platforms, and conference presentations, real DevOps is surprisingly boring.
It’s communication.
It’s automation where automation makes sense.
It’s reducing friction between development and operations.
It’s making systems easier to build, deploy, and maintain.
Unfortunately, “reasonable collaboration between teams” is difficult to sell as a keynote presentation.
So instead we get another talk called:
“Revolutionizing Enterprise Delivery Through AI-Powered Cloud-Native Platform Engineering.”
Which is DevOps bullshit for:
“We made deployments slightly faster.”
And honestly, that’s probably enough.