When deploying one application to multiple customers’ clusters, the first problem is not the template but where the values live. When EKS, AKS, GKE, and on-premises environments are mixed, a single chart must accommodate differences in ingress controllers, storage classes, private registries, and Kubernetes versions. The more conditionals a chart contains, the broader the validation scope becomes with every change.
Adding Helm branches for individual customers may be fast at first, but once the chart absorbs every exception in a customer’s implementation, shared logic and environment-specific configuration become intertwined. In a chart with layers of if statements, it becomes increasingly difficult to determine which customer configurations a change affects, eventually leading no one to touch the template.
Adding More Charts Alone Does Not Resolve Complexity
Before choosing between a single chart, multiple charts, or customer-specific forks, you need to define management boundaries. A single chart makes it easier to maintain a shared deployment flow, but values and branches tend to accumulate inside the chart. Forks can isolate customer changes, but they complicate merging upstream updates and security patches and make release propagation harder. One compromise is to maintain a validated shared template in an upstream repository while customers manage their changes through limited forks.
More important in practice is not increasing the number of charts, but limiting what the charts decide. Conditions that require structural differences, such as whether a component is installed, should remain in the template, while environment differences such as controller names and annotations should move into data.
Separate Management Points with Base Values and Customer Overlays
Keep shared defaults in the base values.yaml and record only the values that actually differ in customer overlays. Duplicating every value for each customer makes it difficult to distinguish shared chart modifications from customer configuration changes. Storing only the differences makes comparisons between customers and reproduction of specific configurations easier while also reducing the impact of chart changes.
Helm can merge multiple values files in sequence. The following example applies a customer overlay after the shared base values.
helm template./chart -f values/base.yaml -f values/customer-a.yaml
helmfile -f environments/eks.yaml apply
This combination can be automated with helmfile or Kustomize. Kustomize is useful for isolating resource differences that are difficult to express through values using patches, but management points must be separated when changing chart types or moving selected customers into separate deployments.
Reduce Version Branches with Capabilities
Kubernetes versions and API support can be determined through Helm Capabilities instead of customer-specific flags. Templates can use .Capabilities.KubeVersion and .Capabilities.APIVersions.Has, while CI should render against explicitly specified target versions.
helm template./chart --kube-version 1.30 --api-versions networking.k8s.io/v1/Ingress
However, because helm template does not communicate directly with a cluster, it renders against defaults unless versions and API lists are provided. For maintainability, ingress className, annotations, and storageClassName should be passed through values rather than branching on controller names.
Control Deployments with a Central Repository and Regression Tests
FluxCD and Argo are used less as tools for modifying charts and more as fleet management tools that synchronize chart and values combinations from a central source to each customer cluster. Separating the repository structure from cluster registration details can standardize synchronization paths. A structure that uses Argo as a platform chart reference is another operational option.
Chart changes should not be approved after reviewing only one customer’s output. CI needs deployment regression tests that render representative customer types and compare changed resources and failure conditions. As with artifacts, the number of variations should be limited, semantic versioning should be applied, and breaking changes and upgrade procedures should be documented in release notes. Pull requests should briefly identify the affected customer types and architectures to make reviews more effective.
The original practical discussion addresses maintaining a single Helm chart across 55 customer clusters. The central point is not to add more automation tools, but to separate responsibility for charts, values, deployment pipelines, and change management.
Realistic Limits and Antipatterns to Avoid
Moving to layered values can reveal duplicated values and incorrect overrides. Too many values merely shift the complexity from chart management to value management, so items that can be covered by shared defaults should continue to be reduced. Even when changing chart types with FluxCD, moving only some customers into separate deployments can create substantial conflicts.
The riskiest approach is to keep adding customer-specific conditionals to the chart or have the central chart directly manage every exception. Conversely, leaving only forks that give customers complete control over their charts slows update and patch propagation. A shared upstream repository, limited customer overlays, automated rendering validation, and an explicit change policy must operate together.
What to Try Now
- Classify the conditionals in the current template and separate component installation decisions from data differences.
- Create shared
values/base.yamland customer-specific overlays, then compare the actual output usinghelm template. - Add customer-specific Kubernetes versions and API lists to the CI rendering options.
- Move ingress classes, annotations, and storage classes into values to eliminate controller-name branching.
- Reference customer combinations from FluxCD or Argo repositories and add rendering regression tests for all representative customer groups.
Original Source
This article was written after reviewing the following source: r/devops — How do you maintain one Helm chart across 50+ customer clusters you don’t control

Leave a Reply