Slicing GitOps Baloney Thin

During much of my tech career, I dealt in precision. Precision tolerances for hardware products. Precise specifications for software. marketing language that favored exactitude.

Oh wait. That last one is not entirely true. In fact, even in technical marketing where precise language would seem to be appreciated, vague and even obtuse language is often rewarded. This drives plausible deniability which, in turn, benefits companies when products don’t work as advertised. It’s true across all products, even IT ones. More importantly, it allows marketers to set their products apart from otherwise similar ones.

That brings me to my latest pet peeve – the term GitOps. This particular rant started on Mastodon after a tech journalist I respect a lot (one of the few that grok the technical stuff) wrote an article referencing the term. The article was, as usual, excellent. The title, however, lit my fuse about GitOps.

My complaint is that GitOps is just another name for Continuous Integration (CI) or maybe Continuous Integration/Continuous Deployment(CI/CD). To be more charitable, it was CI using some variant of the open source git (and yes it’s lower case) project. GitOps is, in my opinion, an example of slicing the baloney too thin. So thin, in fact that it becomes meaningless.

At that point, one of the maintainers of the OpenGitOps project, Roberth Strand,  pointed me at the project’s website. I appreciate that, by the way. It’s always a sign of good community when members suggest resources to each other. Mr. Strand especially wanted me to look at the the guiding principles of GitOps. They are 1 :

  • Declarative – A system managed by GitOps must have its desired state expressed declaratively.
  • Versioned and Immutable – Desired state is stored in a way that enforces immutability, versioning and retains a complete version history.
  • Pulled Automatically – Software agents automatically pull the desired state declarations from the source.
  • Continuously Reconciled – Software agents continuously observe actual system state and attempt to apply the desired state.

What you may notice is lacking is any mention of git itself. That’s right, GitOps doesn’t require git at all. Why call it GitOps then? Weird, right?

The other thing that is immediately noticeable is that these principles would apply to most CI systems. Granted some are not driven by declarative languages, but I would argue most are. Ultimately this looks like a specific implementation of CI.

Back to our baloney. This is an example of trying to create an entire category – be it software, product, or community – from a specific case of an existing term. It’s good marketing. Afraid you might drown in the growing sea of CI/CD products, projects, and companies? Narrow the scope and call it something else. Now whatever you are doing sounds new and fresh. Yay!

The downside is, of course, confusion. It walks like a duck, quacks like a duck, but everyone is told it’s not a duck. Instead, consumers (IT pros in this case) are told to believe that a Mallard is different from a duck. The proliferation of technical terms that mean almost the same thing or that are just subsets of subsets makes decision making much harder. Consumers have to spend too much time just figuring out the starting point.

I suspect that enough companies and organizations such as the CNCF have taken up the term GitOps that it is here to stay. There’s no turning back. What is important is that GitOps not be seen as anything more than a specific case of CI, which is only part of the CI/CD pipeline landscape. Ignore the marketing and look under the covers. You might need some CI software or processes, and they may be called GitOps. You don’t need both and they are not competing with each other, except for the marketing.


  1. Source: OpenGitOps,

Comments are closed.