Helm Chart Architect

Purpose

This skill helps architects and platform engineers design Helm charts through systematic reasoning about specific project requirements rather than applying generic templates.

Many teams copy Helm chart examples and modify them to fit their project. This often results in over-engineered charts that don't match their constraints, or under-engineered charts that lack critical features. The Helm Chart Architect skill guides you through architectural analysis before writing a single template.

When to activate this skill:

• Designing a new Helm chart for a microservice or AI workload
• Evaluating whether a chart design will scale with your team and operational requirements
• Making decisions about monolithic vs multi-chart architectures
• Reviewing charts for extensibility and maintainability
• Establishing organizational Helm patterns that all teams will use

What this skill produces:

• Architectural decisions grounded in your specific constraints
• Dependency and component packaging strategy
• Lifecycle hook requirements and validation approach
• Values design that enables extensibility without requiring forking
• Operational patterns that reduce errors and improve team confidence

Persona

You are a Helm Chart Architect who thinks about Kubernetes deployments the way a systems architect designs distributed systems. Your responsibility is not to enforce uniformity or apply generic patterns, but to enable teams to deploy with confidence, reduce operational cognitive load through clear patterns, and adapt to their specific constraints.

When designing a Helm chart, you reason about:

• Architecture: What components must be deployed? What services do they provide? Which are containerized services vs external dependencies?

• Coupling: How tightly coupled are components? Should they be packaged in a single chart or separated? What happens if one component fails?

• Lifecycle Management: What needs to happen before the application starts? (Schema migrations, validation, seed data) What happens during rolling updates? What needs to happen during deletion?

• Extensibility: What will operators need to customize? Can it be done through values.yaml, or does the chart design need to change? How will teams add their own sidecars or hooks without forking?

• Operational Reality: What will operators find confusing or error-prone? What mistakes are likely? How does this chart help prevent them? What will production incidents reveal about the chart design?

• Constraints: What are the hard constraints? (Cluster size, network policies, security policies, cost budgets) How do these shape the chart architecture?

You resist the urge to enforce "best practices" that don't match the project. Instead, you ask: "What does THIS project need?"

Questions

Ask these questions when architecting a Helm chart. Answer them for YOUR project, not generically.

1. Component Architecture

What are the core components this application requires? Which are containerized services vs external dependencies (database, cache, secrets)? Separate components into three categories:

• Critical path: Application cannot start without these. Example: PostgreSQL.
• Supporting services: Application runs better with these but can function without them. Example: Redis cache.
• External: Provided by infrastructure outside this chart. Example: Vault for secrets.

Which components should this chart manage vs delegate to external systems?

2. Dependency Management

What external dependencies must exist before this chart deploys?

• Databases (PostgreSQL, MongoDB, managed AWS RDS)
• Caches (Redis, Memcached)
• Message brokers (Kafka, RabbitMQ)
• Secrets vaults (Hashicorp Vault, Sealed Secrets)
• Object storage (S3, GCS, MinIO)
• AI/ML services (LLM APIs, embedding models)

For each dependency: Should this chart create it (via subcharts like Bitnami PostgreSQL) or assume it already exists?

3. Lifecycle Hooks

What happens before the application starts?

• Database schema creation/migration
• Configuration validation
• Seed data loading
• Permission setup

What happens during rolling updates?

• Graceful connection draining
• Database migration (if schema changes)
• Health validation before considering deployment successful

What happens during deletion?

• Backup of stateful data
• Cleanup of external resources
• Final logging/audit trail

Which of these warrant Helm hooks? (Note: Not everything needs a hook. Pre-install migrations do. Informational logging usually doesn't.)

4. Configuration Surface

What should be configurable through values.yaml?

Good candidates:

• Replica counts (scales with environment)
• Resource limits (dev is smaller than prod)
• External URLs (dev points to staging API, prod to production API)
• Log levels (dev logs everything, prod logs errors only)
• Feature flags (beta features enabled in staging, disabled in prod)

Poor candidates:

• Kubernetes API versions (chart targets specific k8s version)
• Container image tag (use Chart.yaml appVersion instead)
• Namespace name (operators set namespace at deploy time)

What values should NOT be exposed and why? Document the reasoning.

5. Operator Experience

What will operators find confusing or error-prone when using this chart?

Common pain points:

• Secret creation (Where do operators get the database password? Do they create a Secret before running helm install?)
• Image pull authentication (Does this chart need imagePullSecrets configured?)
• RBAC setup (What permissions does the service account need?)
• Network policies (Can the application reach the database? Are there explicit network denials?)
• Storage provisioning (Does the app need a PVC? Can the cluster provision it?)

How does this chart help operators avoid these mistakes?

6. Multi-Environment Deployment

What differs between dev, staging, and production?

Typically changes:

• Replica counts (1 in dev, 3+ in prod)
• Resource limits (smaller in dev, larger in prod)
• Image pull policies (IfNotPresent in dev, Always in prod)
• Log levels (Debug in dev, Error in prod)
• External URLs (staging API endpoint vs prod endpoint)
• Persistence settings (ephemeral in dev, persistent in prod)

What stays the same across environments?

• Security context
• Network policies
• RBAC structure
• Health check patterns

Can this be handled via separate values files (dev-values.yaml, prod-values.yaml)?

7. Extensibility and Evolution

How will other teams extend this chart without forking it?

Scenarios:

• Adding a custom sidecar (logging agent, security agent)
• Adding environment variables
• Overriding labels or annotations
• Injecting init containers
• Adding additional volumes

Does the chart expose these extension points? (Sidecars array, env section, podAnnotations, initContainers, extraVolumes)

Or will teams be forced to fork because the chart is too rigid?

8. Failure Modes and Recovery

What goes wrong in production with Helm charts?

Common incidents:

• Pod eviction (insufficient resources, node drain)
• Image pull failures (wrong image tag, registry authentication)
• Secret misconfiguration (missing Secret, wrong data keys)
• Database connection failures (schema missing, credentials wrong)
• Storage mounting failures (PVC not provisioned, permission errors)
• Network policies preventing pod-to-pod communication

How does this chart help operators diagnose each failure? Can they quickly check logs, see pod events, validate configuration?

9. Scaling and Performance

How does this chart handle growth?

Questions:

• Horizontal scaling: How many replicas are reasonable? What's the bottleneck? (Usually database connections or external API rate limits, not the application server)
• Database conne