What is Helm, and when should you use Helm, Kustomize or an operator?

Helm is the package manager for Kubernetes: it bundles templated manifests into a chart, renders them with configuration values and installs the result into a cluster as a versioned release that can be upgraded and rolled back. Kustomize customizes plain YAML with overlays and patches instead of templates, and it is built into kubectl. An operator is a controller that keeps running in the cluster and handles day-2 work, such as backups and failover, that neither Helm nor Kustomize does after installation.

Charts, values and releases

Helm has three core concepts:

ConceptWhat it is
ChartA directory or .tgz archive with Chart.yaml (metadata), values.yaml (defaults) and a templates/ folder of manifests written in Go templates
ValuesConfiguration passed into the templates, from the chart’s values.yaml and from your overrides with -f values-prod.yaml or --set
ReleaseOne installed instance of a chart in a cluster, with a name and a revision number that grows with each upgrade

Running helm install renders the templates and applies the manifests. helm upgrade renders a new revision, and helm rollback returns to an earlier one. By default, Helm stores release information in Secrets in the namespace of the release, so the history lives in the cluster, not on the machine that ran the command.

Charts can depend on other charts, declared in the dependencies field of Chart.yaml (Helm chart docs). This is how a single application chart pulls in a database or cache chart. Public charts for most open-source software mean that installing an ingress controller or a monitoring stack is usually one command plus a values file.

The cost is the template layer. Charts with many conditionals and nested values are hard to read and review, and a chart only exposes the settings its author put into values.yaml. Changing anything else means forking the chart or post-processing its output.

What changed in Helm 4

Helm 4.0.0 was released on November 12, 2025, the first new major version in six years. The main changes:

  • Server-side apply. New releases use Kubernetes server-side apply by default, so the API server tracks field ownership. Releases created with Helm 3 keep client-side apply after upgrading unless you set --server-side (Helm 4 overview).
  • Waiting based on kstatus, a more accurate way to decide when resources are ready.
  • A redesigned plugin system that supports WebAssembly plugins; post-renderers are now plugins.
  • Reproducible chart archives, local content-based caching and structured logging for the SDK.

Existing apiVersion: v2 charts keep working. Helm 3 received its last bug-fix release on September 9, 2026, and its security fixes end on February 10, 2027, after which no Helm 3 releases of any kind will ship. Pipelines that still pin a Helm 3 binary should move before then.

Charts in OCI registries

Since Helm 3.8.0, charts can be stored in any OCI-compliant container registry, next to the images they deploy (Helm registry docs):

bash
helm push mychart-0.1.0.tgz oci://registry.example.com/charts
helm install myrelease oci://registry.example.com/charts/mychart --version 0.1.0

This removes the need for a separate chart repository server and reuses the registry’s authentication and access control. A chart can also be installed by digest (oci://.../mychart@sha256:...), which pins the exact bytes the same way an image digest does. The article on image supply chain security explains why digests and signatures matter.

Kustomize: patches instead of templates

Kustomize describes itself as customizing configuration “free from templates and DSLs” (Kustomize guide). You keep a base of ordinary manifests and add an overlay per environment that patches it, for example a higher replica count and a different image tag for production. kubectl has supported Kustomize since version 1.14, so kubectl apply -k overlays/production needs no extra tool.

Because every file is valid Kubernetes YAML, Kustomize is easy to review in a pull request. It has no release object, revision history or rollback command, and no package ecosystem. It fits best for manifests your own team writes.

The two combine. A common pattern renders a third-party chart with Helm and then applies a few Kustomize patches for settings the chart does not expose.

Operators: logic that keeps running

An operator extends the Kubernetes API with custom resources and runs a controller that reconciles them continuously. A database operator, for example, creates replicas, takes scheduled backups, promotes a new primary after a failure and performs version upgrades in the right order. Helm and Kustomize stop working once the manifests are applied; an operator keeps acting on the application’s state. The blog post on Kubernetes operators explains the pattern and compares operators with Helm in more depth.

Operators and Helm are not alternatives in practice. Many operators are installed from a Helm chart, and the operator then manages the application from that point on.

Helm vs Kustomize vs operator

HelmKustomizeOperator
ApproachGo templates plus valuesPatches on plain YAMLController and custom resources
Runs after installNoNoYes, continuously
Versioned releases and rollbackYesNo, rely on Git historyDepends on the operator
DistributionCharts in repositories or OCI registriesDirectories in GitUsually a chart or manifests for the operator itself
Best forInstalling third-party software, sharing an app across many teamsYour own manifests with per-environment differencesStateful or complex software with day-2 operations
Main drawbackTemplates are hard to read and reviewNo packaging or lifecycleAnother controller to run, trust and upgrade

How to choose

  • Installing open-source software such as ingress controllers, cert-manager or monitoring: use the project’s Helm chart.
  • Deploying your own stateless services to a few environments: Kustomize overlays, or a small internal Helm chart if many teams share the same structure.
  • Running databases, message queues or anything with failover and backups: use an operator if a maintained one exists.
  • Managing many releases together: Helmfile, or a GitOps controller that applies charts and Kustomize directories from Git. The article on GitOps covers the pull model, and the Argo CD and Flux comparison explains that Argo CD renders charts with helm template while Flux performs real Helm releases.

Whichever tool renders the manifests, the pipeline that ships them follows the same steps, described in the guide to deploying to Kubernetes from CI/CD.

Helm on Cloudfleet

Cloudfleet Kubernetes Engine (CFKE) runs standard Kubernetes, so Helm charts, Kustomize overlays and operators install without changes. Cloudfleet Container Registry stores Helm charts as OCI artifacts next to your container images, in one registry.

On this page