A Helm chart review should do more than confirm that templates render. Use this reusable checklist to examine values, Kubernetes manifests, security controls, dependencies, and upgrade behavior before a chart reaches a shared or production cluster.
Overview
Helm packages Kubernetes resources into a repeatable release format, but a chart can be syntactically valid and still be unsafe, difficult to configure, or fragile during upgrades. A useful review therefore covers three questions:
- Can the chart render valid resources? Templates should produce manifests that match the intended Kubernetes API versions and workload behavior.
- Can operators configure it safely? Values should be understandable, constrained, and consistent across development, staging, and production.
- Can the release be operated and upgraded predictably? Probes, resources, permissions, hooks, dependencies, tests, and rollback behavior should be explicit.
Apply the checklist to a new chart, a significant template change, a dependency upgrade, and every production promotion. Pair it with your normal code-review process and with cluster-level controls such as admission policies. For related infrastructure review practices, see the Terraform module standards checklist and the Kubernetes security checklist.
Baseline review commands
Run checks locally or in CI before inspecting the rendered YAML:
helm lint ./chart
helm dependency build ./chart
helm template my-release ./chart \
--namespace example \
--values values.yaml \
--values values-production.yaml \
--debug
helm upgrade --install my-release ./chart \
--namespace example \
--create-namespace \
--dry-run=server \
--debugUse --dry-run=server only when the review environment can access a suitable cluster and you want server-side validation. A local render does not prove that the target cluster supports every API, admission rule, or configuration. If the chart defines release tests, run them after installation with helm test my-release.
Checklist by scenario
1. Reviewing chart structure and values
- Chart metadata: Confirm the chart name, version, application version, description, maintainers, and declared chart API version are intentional. Check that version changes follow the team’s release convention.
- Values design: Group values by component and use names that describe behavior rather than implementation details. Keep defaults safe for a non-production environment.
- Environment overrides: Review each values file as a complete configuration. Look for production overrides that silently disable probes, persistence, authentication, network restrictions, or resource limits.
- Schema validation: Add a
values.schema.jsonfile where practical. Define types, permitted values, required fields, and useful bounds for settings such as replica counts, ports, image references, and resource quantities. - Secret inputs: Make it clear which values are sensitive. Prefer references to existing Kubernetes Secrets or an external secret workflow rather than storing credentials in a chart repository or ordinary values file.
- Deprecation: Document renamed or removed values and provide a migration path. Avoid keeping multiple aliases indefinitely unless the compatibility requirement is explicit.
2. Reviewing templates and rendered manifests
- Names and labels: Check that names are deterministic and within Kubernetes limits. Standard labels should consistently identify the application, chart or release, component, and managed resources.
- Template functions: Review
include,tpl,toYaml, indentation, quoting, conditionals, and defaulting. Confirm that optional blocks do not leave invalid YAML or unintended empty fields. - API compatibility: Compare rendered resources with the Kubernetes versions supported by the platform. Pay particular attention to deprecated APIs, ingress behavior, policy resources, and custom resources.
- Workload behavior: Verify selectors, pod labels, container commands, ports, security contexts, volume mounts, service names, and rollout strategy. Selector changes can make an upgrade unsafe, so treat them as a deliberate migration.
- Health checks: Configure startup, readiness, and liveness probes according to actual application behavior. A liveness probe should not restart an application merely because it is still starting or temporarily dependent on another service.
- Resources: Set requests and limits where the platform requires them. Check that defaults are realistic and that autoscaling settings do not conflict with fixed replica values.
- Scheduling: Review affinity, topology spread, tolerations, priority, and disruption settings when availability depends on them. Avoid hard constraints that make a workload unschedulable in smaller environments.
3. Reviewing Kubernetes security
- Pod security: Use a non-root user where the application supports it, prevent privilege escalation where possible, drop unnecessary Linux capabilities, and set an appropriate seccomp profile.
- RBAC: Inspect every ServiceAccount, Role, and RoleBinding. Scope permissions to the required namespace and resources; question wildcard verbs, wildcard resources, cluster-wide bindings, and unused service accounts.
- Network access: Determine whether NetworkPolicies are required and whether the chart’s defaults permit only the traffic the application needs. Document any assumption that the cluster supplies a separate policy.
- Images: Pin images by an approved tag or digest according to your release policy. Review pull secrets, registries, and whether the chart exposes an unsafe way to replace the image.
- Secrets: Confirm that rendered output, CI logs, dry-run output, and release metadata will not expose sensitive values. Do not assume that base64 encoding provides confidentiality.
- Admission controls: Render the chart through the same policy checks used by the target cluster when possible. OPA or Kyverno policies can catch violations before deployment; see the guide to policy as code with OPA and Kyverno.
4. Reviewing dependencies, hooks, and release behavior
- Dependencies: Inspect
Chart.yamland the lock file. Confirm repository sources, version ranges, aliases, conditions, and whether dependency updates alter permissions or rendered resources. - Hooks: Review hook annotations, execution order, deletion policy, timeout behavior, and failure handling. A hook that creates data, migrates a schema, or blocks an upgrade needs an explicit recovery plan.
- CRDs: Treat custom resource definitions as a special upgrade concern. Verify ownership, installation order, compatibility, and how schema changes are applied; do not rely on an ordinary rollback to reverse every CRD change.
- Upgrade and rollback: Test upgrades from the currently deployed chart version, not only fresh installs. Confirm that immutable fields, renamed resources, PVCs, jobs, and database migrations have a documented path.
- Release tests: Include focused tests for connectivity, readiness, and the most important user-facing path. Make test cleanup predictable and ensure tests do not require production data or broad permissions.
What to double-check
Use the following review table as a pull-request summary. Mark each item pass, change requested, or not applicable, and record evidence for exceptions.
| Area | Reviewer question | Evidence to request |
|---|---|---|
| Values | Can an operator identify required and sensitive settings? | Schema, documented examples, and environment values |
| Rendering | Do all supported configurations produce valid manifests? | Lint output and rendered manifests for each scenario |
| Security | Are identity, secrets, image, and pod permissions minimized? | RBAC diff, security context, policy results, secret workflow |
| Reliability | Will Kubernetes know when to start, route to, and restart the workload? | Probe rationale, resource settings, rollout configuration |
| Compatibility | Do APIs and fields match the target cluster versions? | Supported-version matrix or server-side validation |
| Upgrade | What happens to existing resources and data during an upgrade? | Upgrade test, migration notes, rollback or recovery plan |
| Operations | Can responders diagnose failures without chart-specific guesswork? | Notes, dashboards, logs, alerts, and test instructions |
Compare rendered output between chart revisions rather than reviewing only template files. A manifest diff can expose a changed selector, removed volume, new permission, altered service port, or unexpectedly recreated resource. Also inspect the release namespace and cluster context before running any command that can install or modify resources.
Common mistakes
- Testing only a default install: A chart may work with defaults while failing with production values. Render at least one minimal, standard, and production-like configuration.
- Putting secrets in values files: Private repositories and encrypted-at-rest storage do not remove the risk of accidental exposure in pull requests, logs, or release metadata. Design a secret reference workflow instead.
- Using
tplwithout a clear need: Evaluating values as templates increases complexity and can make input behavior harder to reason about. Restrict it to documented cases. - Adding broad RBAC for convenience: A deployment that cannot start because of one missing permission should receive a precise permission, not an unbounded cluster role.
- Treating probes as decoration: Copying generic probes can cause restart loops, traffic to unready pods, or slow rollouts. Tie thresholds and paths to measured application behavior.
- Assuming rollback reverses everything: Database migrations, external resources, hooks, and CRD changes may require a forward repair or a separate recovery procedure.
- Ignoring rendered output: YAML that looks reasonable in a template can render differently because of indentation, empty values, quoting, or conditional logic.
- Bundling uncontrolled dependencies: A dependency update can introduce new resources, permissions, or defaults. Review it like application code, not as a passive package change.
For incidents caused by failed deployments or unhealthy pods, keep a troubleshooting path separate from the chart review. The CrashLoopBackOff decision tree is useful when a release has already reached the cluster, while an SRE incident response template can structure escalation and recovery.
When to revisit
Revisit this checklist before every production promotion and whenever the chart, its dependencies, or the target platform changes. Schedule a broader review before seasonal planning cycles or other periods when deployment volume and ownership change. Trigger an immediate review when you:
- upgrade Helm, Kubernetes, an ingress controller, a service mesh, or a policy engine;
- change chart APIs, values schema, image sources, storage, probes, selectors, or security contexts;
- add a dependency, hook, CRD, migration job, ServiceAccount, or cluster-scoped resource;
- change admission policies, namespace controls, secret management, or supported environments;
- experience a failed upgrade, rollback, security finding, unexpected cost, or recurring reliability issue.
Make the checklist part of the repository. Store supported-environment assumptions, example values, test commands, and upgrade notes beside the chart. Assign an owner to review the checklist at least when workflows or tools change, and update command examples and compatibility guidance whenever your Helm or Kubernetes support policy changes. The goal is not a one-time approval; it is a small, repeatable control that keeps chart behavior understandable as the platform evolves.