Recommended Free Tools
If you run the same application in staging and production, you probably keep near-identical copies of a Deployment, a Service, and a ConfigMap, and every change means editing each copy by hand. Helm packages those related resources as a chart, fills in the parts that differ from a set of values, and records each installation as a named release that you can upgrade or roll back. It does not remove YAML. Someone still writes the templates and values, and what reaches the cluster is ordinary Kubernetes resources.
The problem Helm addresses
Consider a web application deployed to three environments. The Deployment, Service, and ConfigMap are almost the same everywhere. The differences are a handful of values: how many replicas run, which image tag is deployed, and which hostname the ingress answers to. With raw manifests, each environment gets its own copy of every file, and the copies drift apart as people fix one and forget the others.
As an Amazon Associate I earn from qualifying purchases.
The table below shows the kind of values that typically differ. The numbers are illustrative for this example, not Helm defaults.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
| Setting | Development | Staging | Production |
|---|---|---|---|
| Replica count | 1 | 2 | 5 |
| Image tag | 1.4.3-rc1 | 1.4.2 | 1.4.2 |
| Ingress host | web.dev.example.com | web.staging.example.com | www.example.com |
Helm’s goal is to keep the shared structure in one place and make the differences explicit. Each environment then becomes a small set of overrides instead of a full set of files.
#1 Best Overall
What Helm is, and the three terms you need
The Helm project describes itself in its introduction with two sentences worth keeping in mind. The first is “Helm is the package manager for Kubernetes.” The second is “Helm focuses on the application running in the cluster rather than the cluster itself.” Helm is therefore aimed at packaging and managing applications, not at creating or operating the cluster. Helm Introduction
Three terms carry most of the meaning:
- Chart: the package. It groups the resource definitions for one application, along with metadata and default values.
- Repository: a place where charts are collected and shared so others can install them.
- Release: one installed instance of a chart in a cluster. The same chart can be installed more than once under different release names. For example,
helm install web-dev ./webappandhelm install web-prod ./webapp -f values-prod.yamlcreate two independent releases from one chart.
How a chart becomes Kubernetes resources
The flow runs in four stages: a chart and its values are combined, the templates are rendered into plain Kubernetes manifests, those manifests are applied to the cluster, and the result is tracked as a release. The rendered objects are standard Deployments, Services, and ConfigMaps. Helm does not introduce a new runtime object type for them.
A typical chart layout looks like this:
webapp/
Chart.yaml
values.yaml
templates/
deployment.yaml
service.yaml
configmap.yaml
charts/
crds/Chart.yaml
This file holds the chart’s metadata, including its name and version. Keep the chart version separate from the version of the application it deploys. Changing the chart’s structure and changing the application image are different kinds of change, and they should be tracked separately.
values.yaml
This file holds the default configuration. Anything that varies between environments belongs here, so the templates can refer to it by name instead of hard-coding it:
replicaCount: 2
image:
repository: registry.example.com/web
tag: 1.4.2templates/
Each file here is a Kubernetes manifest with placeholders. Helm templates use Go template syntax, so a Deployment might contain:
spec:
replicas: {{ .Values.replicaCount }}
template:
spec:
containers:
- name: web
image: {{ .Values.image.repository }}:{{ .Values.image.tag }}A production environment then supplies only what differs. A file named values-prod.yaml might set replicaCount: 5 and override the image tag, and everything else comes from the chart defaults.
To see exactly what would be sent to the cluster without installing anything, render the chart locally:
helm template web-prod ./webapp -f values-prod.yamlDependencies
A chart can declare other charts it depends on, such as a database or cache chart, so that a single install brings in the whole set. Dependencies are declared in the chart metadata and stored under the charts/ directory. Check the chart guide for the exact dependency syntax before you rely on it, since the file format is part of the chart definition.
The release lifecycle
Once a chart is installed, Helm tracks every change to it as a numbered revision of the release. The usual sequence looks like this:
Rank #4
- Install. Run
helm install web-prod ./webapp -f values-prod.yaml. This creates releaseweb-prodat revision 1. - Upgrade. After you change the chart or its values, run
helm upgrade web-prod ./webapp -f values-prod.yaml. This creates a new revision. - Inspect history. Run
helm history web-prodto list the revisions and their status. - Roll back. Run
helm rollback web-prod 1to return the release to revision 1.
Rollback restores the Kubernetes resources Helm manages to the state recorded in an earlier revision. It is not a guarantee of full recovery. Helm does not undo database migrations, data your application has written, or changes made outside the chart, so those need their own rollback plan. Helm Introduction
Converting existing YAML into a chart
The practical path for a team with existing manifests is incremental. Start by creating a chart skeleton, move your manifests into it, and then replace the environment-specific values with template references.
- Scaffold a chart. Run
helm create webapp. This generates a chart with example templates. Replace those examples with your own manifests intemplates/. - Parameterize the differences. Move values that vary, such as replica counts, image tags, and hostnames, into
values.yaml. Replace each hard-coded value in the templates with a reference such as{{ .Values.replicaCount }}. - Check the chart structure. Run
helm lint ./webappto catch structural errors before rendering. - Compare rendered output with the originals. Render the chart with each environment’s values file, for example
helm template web-staging ./webapp -f values-staging.yaml, and compare the output with the manifests you were running before. Differences should be intentional. - Install into a test namespace first. Run
helm install webapp-test ./webapp --namespace test --create-namespaceand confirm the resources behave as expected. - Check for existing objects. If the cluster already contains resources with the same names that were created by hand or by another tool, resolve that before installing the release over them. Helm needs to own the objects it manages.
CRD behavior depends on the Helm version
Custom Resource Definitions need separate handling. The chart guide describes the Helm 3 behavior: YAML in the crds/ directory is not templated, and Helm does not automatically upgrade or delete those CRDs. Treat that as version-specific guidance rather than a general Helm rule. Before you write a CRD upgrade procedure, confirm the current behavior for the Helm version your team runs in the Helm Charts guide, because Helm 4 is now the stable major version.
Which Helm version to plan around
The Helm project repository lists the current release and support status. As of October 9, 2026, the position is as follows.
| Version | Status in the project repository | Dates |
|---|---|---|
| Helm 4 | Stable. Helm 4.3.0 is the latest release. | Helm 4.3.0 released September 9, 2026 |
| Helm 3 | Support mode | Bug fixes through July 8, 2026 (now ended); security fixes through November 11, 2026 |
Source: helm/helm on GitHub. These are project lifecycle dates, not performance measurements. Check the repository again before making a long-term upgrade decision, because release and support dates change.
Raw manifests or a Helm chart?
There are two practical options: keep hand-maintained manifests, or package them as a chart. The comparison below uses four axes. The learning-curve row is a judgment about practical effort, not a measured result.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →| Consideration | Raw manifests | Helm chart |
|---|---|---|
| Reuse across environments | Usually one file set per environment, edited separately | One chart with a values file per environment |
| Release history and rollback | No built-in revision record; rolling back means re-applying an older file set you kept | Numbered release revisions with helm history and helm rollback |
| Learning and template complexity | Low: what you write is what runs | Higher: template syntax, values structure, and chart layout must be learned and maintained |
| Fit | A small, stable application with one environment | Several environments, frequent changes, or packaging for others to install |
When Helm may be unnecessary
For a very small, stable deployment, hand-maintained manifests are often simpler than a chart. Plain manifests may be enough when:
- the application runs in one environment and changes rarely;
- the team has no need for named release history or quick rollback through Helm;
- nobody on the team wants to maintain template logic alongside the Kubernetes resources.
This is editorial judgment rather than a documented rule. Once the same manifests begin to be copied across environments, the copies are the signal that a chart would help.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
