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:
| Concept | What it is |
|---|---|
| Chart | A directory or .tgz archive with Chart.yaml (metadata), values.yaml (defaults) and a templates/ folder of manifests written in Go templates |
| Values | Configuration passed into the templates, from the chart’s values.yaml and from your overrides with -f values-prod.yaml or --set |
| Release | One 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):
helm push mychart-0.1.0.tgz oci://registry.example.com/charts
helm install myrelease oci://registry.example.com/charts/mychart --version 0.1.0This 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
| Helm | Kustomize | Operator | |
|---|---|---|---|
| Approach | Go templates plus values | Patches on plain YAML | Controller and custom resources |
| Runs after install | No | No | Yes, continuously |
| Versioned releases and rollback | Yes | No, rely on Git history | Depends on the operator |
| Distribution | Charts in repositories or OCI registries | Directories in Git | Usually a chart or manifests for the operator itself |
| Best for | Installing third-party software, sharing an app across many teams | Your own manifests with per-environment differences | Stateful or complex software with day-2 operations |
| Main drawback | Templates are hard to read and review | No packaging or lifecycle | Another 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 templatewhile 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.