Why is GitOps Good for Developers and Operations (and their career)?

Cloud-native engineers have a variety of job titles and roles throughout their career. From Ops to DevOps to GitOps, the career path is challenging and innovative and requires constant learning.

It feels like we just started with the DevOps movement that spawned CI/CD tools more than a decade ago. The promise was to tear down the silos that separated development and operations teams, leading to dramatic improvements in software engineering efficiency.

It’s true that DevOps has increased software release velocity. However, I believe it has come up short in many areas. Such as in codifying best practices across multiple development projects and incorporating the complexities of cloud infrastructure deployment. It also requires deep and sometimes esoteric skills by dedicated DevOps engineers who spend full days just setting up and managing tool chains and infrastructure.

GitOps:  A More Modern Approach

There is clearly an opportunity for an improved approach that takes the best practices of DevOps (CI/CD tool chains, collaboration between Dev and Ops, etc.) and applies them to advanced architectures and modern development organizations.

GitOps is the natural candidate to provide this next step, especially pertaining to the very messy business of cloud infrastructure. With GitOps, both the application and underlying infrastructure are defined in code that is stored in a centralized version control system (Git). This provides a single source of truth that both the development and operations teams share.

This approach allows developers to setup and change the infrastructure through declarative code, centrally stored. Thereby also allowing for automated correction when the desired and actual state of the infrastructure varies.

Self-Service for Developers

The increased infrastructure automation that comes with GitOps creates the opportunity to develop a more “self-service” approach for application developers. Rather than negotiating for cloud resources, skilled developers can use infrastructure as code (IaC) to declare their cloud resource requirements. This becomes the desired state of the infrastructure, stored centrally and serving as the immutable reference point between the requirements as stated in code and the actual state of the live environment.

This self-service approach is liberating for developers. It makes them more productive, allows them to focus on innovation, gets their apps to market more quickly. Additionally, it avoids the mire that can be introduced when the developers and operators need to negotiate resources.

More Value-Add by Operations / Platform Teams

The benefits for developers as outlined above get most of the attention. In fact, I believe there is a frequent misconception that the increased automation of operations means that Ops teams need fewer people and their role in the pipeline is marginalized. Our view is the exact opposite; we believe that modern approaches such as GitOps and Internal Developer Platforms (IDP) provide exciting opportunities for Ops (or as we call it, the Platform Team) to enhance their skills and create more value for the organization.

In a high-performing, cloud-native software development organization that embraces GitOps, you are likely to find:

• Multiple, independent application teams
• Next-generation tools and processes that improve upon the first generation of CI tools
• A self-service approach to making cloud infrastructure resources available to developers
• A high performing Platform team that is helping to make it all work

The actual technology used by the Platform team will vary. In some cases, this could just be a closed Platform as a Service (PaaS) solution where the cloud abstraction layer is tightly coupled with underlying cloud hosting services. We believe there are major limitations of this approach, including both cost and flexibility. But it was popular about 15 years ago and is still common today.

Another approach is to use various tools to create a bespoke platform that you tailor to your specific organization. With this approach, the platform team takes on the role of both product managers and software engineers. They work closely with the developers to understand their needs, agree on requirements, and then implement those features on the platform.

In either of the above scenarios, the platform team actually takes on a more valuable role in the organization. Also exerts more influence and control over the infrastructure resources and architecture. They create the “guardrails” that enforce a simple, efficient, and standardized approach to cloud-native application deployment.

GitOps: A Great Career Opportunity

Of course, this is as much about the organizational culture as the underlying technology. It’s just that, in our experience, a GitOps approach has made it natural to get to a structure in which developers enjoy increased automation from self-service infrastructure resources and platform engineers enjoy taking on a more influential role in the organization. In that regard, it’s a win-win approach that makes everyone more aligned and fulfilled.