A Helm chart review should verify more than whether a template renders. This reusable checklist helps developers and platform teams inspect chart structure, values, dependencies, rendered Kubernetes manifests, security settings, upgrade behavior, and rollback readiness before installation or release.
Overview
Helm packages Kubernetes manifests with templates, default values, metadata, and optional dependencies. That packaging makes deployments repeatable, but it also creates review risks: a harmless-looking values change can alter permissions, resource consumption, network exposure, or upgrade behavior.
A useful review separates three questions:
- Will the chart render? Templates, values, schemas, and dependencies must work together.
- Will Kubernetes accept and run it safely? Rendered resources should use supported APIs, valid configuration, appropriate security settings, and realistic resource limits.
- Will the release behave predictably over time? Upgrades, rollbacks, hooks, immutable fields, and environment-specific values need explicit consideration.
Review the chart as both source code and generated output. A chart can pass a basic lint check while still producing an overly permissive Role, an invalid production configuration, or a deployment that cannot roll back cleanly.
Keep this checklist with the chart repository or release process. It is particularly useful before a first installation, a dependency update, an environment promotion, or a change to templates or values.
Checklist by scenario
1. First review of a new chart
- Confirm
Chart.yamlcontains the intended chart name, version, application version, description, and chart API version. - Check that the chart directory has a clear structure:
Chart.yaml,values.yaml,templates/, and any documented dependency or test directories. - Read the chart documentation from a new user’s perspective. Required values, supported environments, installation steps, and known limitations should be clear.
- Inspect every template for hard-coded namespaces, image names, ports, hostnames, storage classes, and cloud-specific assumptions.
- Review helper templates in
_helpers.tplfor consistent names, labels, selectors, and annotations. - Check that workload selectors are stable. A selector that changes between releases can make an upgrade fail or cause a workload to be recreated.
- Run
helm dependency buildor the repository’s documented dependency command, then verify that the resulting lock information and packaged dependencies match the intended versions.
2. Review of values and environment configuration
- Group values by purpose, such as image, service, ingress, resources, security context, persistence, autoscaling, and observability.
- Choose safe defaults. Avoid enabling public ingress, privileged containers, broad RBAC, or production-only integrations by default unless the chart explicitly requires them.
- Document which values are required, which are optional, and which combinations are incompatible.
- Use a
values.schema.jsonfile where practical to validate types, required fields, allowed values, and basic constraints. - Check that environment-specific files override only what they need to override. Large copied values files drift easily and make reviews harder.
- Confirm sensitive values are not stored as plain text in the chart, repository, rendered output, or CI logs. Prefer a documented secret-management integration and verify how it behaves during upgrades.
- Review resource requests and limits rather than accepting empty defaults. For a deeper sizing workflow, see the Kubernetes resource requests and limits guide.
3. Pre-install and pre-release validation
- Run
helm lintwith the relevant values files. Linting is an early signal, not a complete release test. - Render the chart for every supported environment with
helm template. Include the release name, namespace, values files, and relevant--setoverrides used by automation. - Save rendered manifests as review artifacts when the release process allows it. Reviewers can inspect the exact output instead of inferring it from templates.
- Validate rendered manifests against the target Kubernetes API expectations. If your team uses a schema or policy validator, run it against the rendered output in CI.
- Search the rendered output for unintended namespaces, empty image tags, duplicate resources, wildcard permissions, privileged settings, host networking, and public endpoints.
- Confirm that CRDs, service accounts, roles, config maps, secrets, workloads, services, ingress objects, and autoscalers are present only when intended.
- Use a dry-run or equivalent environment check as part of the release workflow, while recognizing that client-side rendering alone cannot detect every cluster-side issue.
4. Dependency and image review
- List each dependency and identify why it is included, where it comes from, and which version range or lock entry controls it.
- Review dependency values separately from the parent chart. A parent chart may unintentionally expose or override child-chart settings.
- Check whether dependencies create cluster-wide resources, admission components, CRDs, webhooks, or additional service accounts.
- Use explicit image references, preferably immutable digests where your delivery process supports them. If tags are used, document the update and promotion policy.
- Confirm that image pull secrets, registries, architectures, and startup configuration match the target environments.
- Review the container image itself for a minimal base, non-root operation where possible, and an appropriate entrypoint. The Dockerfile review checklist provides a related inspection workflow.
5. Upgrade, rollback, and production release
- Compare the previous and new rendered manifests, not just the source-code diff.
- Identify immutable or disruptive changes, including selector changes, persistent volume claims, service fields, webhook configuration, and storage-related settings.
- Check readiness and liveness probes, startup timing, termination behavior, and rolling-update settings. These determine whether an upgrade can progress without unnecessary downtime.
- Review Helm hooks carefully. Confirm their timing, deletion policy, idempotence, timeout behavior, and effect on rollback or uninstall.
- Verify that database migrations, one-time jobs, and configuration changes have a recovery plan. A hook that succeeds once may fail when repeated during a retry or rollback.
- Define the rollback command, access requirements, release history expectations, and application-level recovery steps before deployment.
- Test the chart in a representative non-production cluster or namespace. A successful render is not evidence that the application starts, connects to dependencies, or handles traffic correctly.
What to double-check
Rendered security posture
Inspect the generated manifests as an attacker or failure investigator would. Ask whether the workload runs as the intended user, whether Linux capabilities are reduced, whether privilege escalation is disabled where appropriate, and whether the pod can access host resources. Review service accounts, RoleBindings, ClusterRoleBindings, and wildcard verbs or resources. Confirm that a namespace-scoped application does not receive cluster-wide permissions without a documented reason.
Also check network exposure. A Service of type LoadBalancer, a public ingress, host ports, or an incorrectly configured gateway can expose an application beyond its intended boundary. Verify TLS configuration, ingress class selection, and any network policies that are expected to restrict traffic.
Values precedence and type safety
Helm values can come from chart defaults, one or more values files, and command-line overrides. Write down the precedence used by CI/CD and test the exact invocation. A value that works in a local command may be overwritten by a later file in the deployment pipeline.
Be cautious with booleans, numbers, lists, and strings. Quoting a value can change how it is interpreted, while an empty value may render a field that Kubernetes rejects. Schema validation helps, but reviewers should still inspect meaningful combinations, such as autoscaling with fixed replicas or persistence enabled without a usable storage configuration.
Operational behavior
Check labels and annotations used by monitoring, policy, cost reporting, and deployment automation. Confirm that names are deterministic and stay within Kubernetes naming limits. Review log configuration, metrics exposure, service ports, probes, disruption budgets, topology rules, and scheduling constraints.
Make sure resource settings reflect an intentional sizing decision. Requests influence scheduling, while limits can affect runtime behavior. Keep the chart review connected to the team’s sizing process rather than treating resources as decorative configuration.
Compatibility and release evidence
Record the Kubernetes versions, Helm version, chart version, dependency versions, and values files used for validation. Kubernetes APIs and admission behavior can change as clusters are upgraded. The Kubernetes upgrade readiness checklist can help connect chart review with cluster upgrade planning.
A practical sign-off should link to lint output, rendered manifests, policy-validation results, test evidence, and the reviewed diff. This makes a later incident easier to investigate.
Common mistakes
- Reviewing only templates: The important behavior is in the rendered manifests for a specific values combination.
- Treating
helm lintas a complete test: Linting does not replace Kubernetes validation, policy checks, dependency review, or runtime testing. - Using mutable image tags without a promotion plan: The same chart version can then produce different workloads at different times.
- Copying production values into lower environments: This can expose services, consume unnecessary resources, or connect tests to live dependencies.
- Ignoring disabled resources: Review both enabled and disabled paths. A feature may be enabled by a pipeline override even when its default is false.
- Creating secrets in rendered output: A dry-run artifact, CI log, or pull-request comment may retain sensitive data.
- Changing selectors casually: Selector changes can be disruptive and may be rejected by Kubernetes.
- Adding hooks without failure handling: Hooks can block releases, leave temporary resources behind, or behave differently during rollback.
- Assuming rollback restores application state: Helm can restore manifests, but it cannot automatically undo every database migration, external API change, or irreversible data operation.
- Skipping dependency review: A chart update may introduce new permissions, CRDs, webhooks, or configuration defaults.
When to revisit
Run the full checklist before the first installation, each production release, and any change to templates, values, dependencies, images, hooks, RBAC, networking, storage, or security settings. Revisit it after a failed upgrade, rollback, incident, or change in deployment tooling.
Review the checklist on a regular platform-engineering cadence as well, especially before seasonal planning cycles and when workflows or tools change. Update command examples, supported chart and API versions, policy rules, dependency practices, and secret-management guidance after relevant Helm or Kubernetes changes. Do not rely on a date alone: a cluster upgrade or CI/CD migration is a stronger trigger than a calendar reminder.
For a practical release sign-off, copy this sequence into the change record:
- Record chart, dependency, image, Helm, and Kubernetes versions.
- Run schema validation,
helm lint, and rendered-manifest validation for each supported environment. - Compare rendered output with the previous release.
- Review RBAC, secrets, images, resources, networking, probes, hooks, and persistent data behavior.
- Test installation or upgrade in a representative environment.
- Document rollback steps, known risks, approvers, and post-release checks.
- Attach the validation results and approve only after the rendered output matches the intended release.
This process keeps Helm chart review focused on the real deployment contract: what Kubernetes will receive, what the workload will be allowed to do, and how the team will recover when a release does not behave as expected.