Skip to main content
This guide explains how GitOps integrates with continuous integration (CI), observability, and notification systems to form a complete cloud-native delivery pipeline. You’ll also get a concise overview of the DORA metrics that measure delivery performance and reliability. While GitOps makes Git the single source of truth for desired state, it is most powerful when it interoperates with CI systems that build and test artifacts, and with observability/notification tools that provide runtime feedback and automated responses.

​
DORA metrics: key indicators of delivery performance

DORA metrics are industry-standard benchmarks that help teams measure how effectively they deliver and operate software. GitOps naturally encourages practices that improve these metrics.
The image outlines DORA metrics for software delivery performance, including deployment frequency, lead time for changes, change failure rate, and time to restore service.
DORA MetricWhat it measuresWhy it matters
Deployment frequencyHow often new versions are releasedHigher frequency indicates faster delivery and smaller, safer changes
Lead time for changesTime from commit to productionShorter lead times increase responsiveness and reduce feedback delay
Change failure rate% of deployments causing a failure requiring remediationLower rates imply more reliable releases
Time to restore serviceTime to recover after an incidentFaster recovery reduces user impact and increases reliability
DORA metrics are complementary to GitOps: declarative manifests, version control, and automated reconciliation help improve deployment frequency and reduce lead time and failure rates.

​
Continuous Integration (CI) and GitOps

A CI system automates building, testing, and packaging code changes. In a GitOps workflow, CI produces immutable artifacts (for example, container images) and updates the declarative manifests in Git that describe how the application should run.
The image is a diagram illustrating continuous integration with Jenkins, showing a workflow that includes automating CI/CD for building, unit testing, linting, dockerizing, security, deployment, and tests.
Jenkins is a widely used automation server that can orchestrate the pipeline—from unit tests and linting to Docker image builds and security scans—before updating Git with the new desired state.
The image is a diagram showing the benefits of Continuous Integration with Jenkins (CI), highlighting code problem detection, accelerated development, and improved software quality.
Key roles for CI in GitOps:
  • Build and test artifacts (binaries, container images).
  • Push immutable artifacts to a registry.
  • Update Kubernetes manifests or Helm charts in the GitOps repository with the new image tags or config.

​
How GitOps connects CI and the runtime

In a typical GitOps flow, a GitOps operator (e.g., ArgoCD or Flux) continuously compares the Git repository’s desired state to the actual cluster state and reconciles differences.
The image is a flowchart depicting the CI/CD process with GitOps, showing interactions between an application code repository, Kubernetes manifests repository, and a production cluster managed by ArgoCD. It illustrates the steps of continuous integration, version control, and deployment automation.
Example end-to-end sequence:
  1. Developer merges code to the application repository.
  2. CI pipeline runs tests, builds an image, and pushes it to a container registry.
  3. CI updates the Kubernetes manifest repository (e.g., updates image tag).
  4. GitOps operator detects the change in the manifests repo and applies it to the cluster.
  5. Operator monitors application health and reports discrepancies.
The image illustrates a CI/CD workflow using GitOps, detailing processes like application code management, continuous integration, and deployment through Kubernetes and ArgoCD. It shows how code is tested, built, and synchronized with production clusters.
Rollback is straightforward because the desired state is versioned in Git. Reverting a commit or using the GitOps operator’s rollback feature returns the cluster to the previous good state.
Automatic rollbacks can speed recovery but must be used with care. Ensure health checks and observability thresholds are well-defined to avoid oscillations or cascading rollbacks.

​
Observability and notifications: closing the feedback loop

Observability tools collect runtime metrics and logs that inform the GitOps workflow about the health of deployments. Prometheus and Grafana are common choices for metrics and visualization, and Alertmanager handles routing and delivering alerts.
The image illustrates the process of observability and notification using Prometheus, Grafana, AlertManager, and Slack, with Git and Kubernetes integrated into the workflow for deploying and gathering feedback.
Typical observability workflow:
  • Prometheus scrapes metrics from pods and infrastructure.
  • Alertmanager receives alerts based on Prometheus rules.
  • Alertmanager routes notifications to channels such as Slack, email, or webhooks.
  • On a detected regression, the team is notified and may revert the Git manifest or trigger automated remediation.
The image is an infographic titled "Observability and Notification: Prometheus, AlertManager, and Slack," highlighting benefits such as validating successful deployments, providing operational insights, and enabling rapid incident response.
An example scenario:
  • GitOps operator deploys a new version.
  • Prometheus detects increased error rate or latency above thresholds.
  • Alertmanager sends a Slack alert to the on-call channel.
  • The team reverts the manifest in Git (or relies on an automated rollback), and the GitOps operator restores the previous state.
Benefits of integrating observability and notifications with GitOps:
  • Validate deployments automatically.
  • Gain operational insight into production behavior.
  • Enable faster incident detection and response, improving DORA metrics like time to restore service.

​
References and further reading

This overview ties together CI, GitOps, and observability to form a resilient delivery pipeline that supports rapid, safe deployments and clear feedback loops for continuous improvement.

Watch Video