Nicheloom

Market intelligence for builders — see what's gaining traction before it's crowded.

Chart Preview

Preview environments for Helm charts on every PR

Details

External ID
46337764
Source
HN
Company
—
Product
—
Website domain
—
Launched
Dec. 20, 2025
Cohort
—
Upvotes
22
Upvotes percentile
0.6708015267175572
Tags
—
Fetched at
Sept. 7, 2026, 9:25 p.m.
Updated at
Sept. 7, 2026, 9:25 p.m.

Description

I’m a software engineer who accidentally became my team’s Kubernetes person — and eventually the bottleneck for every Helm chart PR.I built Chart Preview so reviewers could see Helm chart changes running without waiting on me.A few years ago, my team needed to implement HA for an existing product, which meant deploying on Kubernetes and OpenShift. I spent months learning Kubernetes, Helm, and the surrounding ecosystem. After that, Kubernetes largely became “my thing” on the team.We later published public Helm charts for the product, and customers started submitting PRs. Those PRs would often sit for months — not because the changes were bad, but because testing them meant manually spinning up a Kubernetes cluster, deploying the chart with the proposed changes, running through test scenarios, and coordinating verification with product and QA. Since I was the only one who could reliably set up those environments, everything waited on me.I kept thinking: what if the PR itself showed the changes working? What if reviewers could just click a link and see it deployed?That idea became Chart Preview.Chart Preview deploys your Helm chart to a real Kubernetes cluster when you open a PR, provides a unique preview URL for that PR, and cleans everything up automatically when the PR closes.I started by solving a problem I was personally hitting, rather than surveying the whole market upfront. As I built more of it, I looked at existing preview tools and noticed that while there are solid solutions for previewing container-based applications, Helm-specific workflows introduce different challenges — chart dependencies, layered values files, and opinionated chart structures. That pushed me to focus Chart Preview on being Helm-native first, rather than adapting a container preview workflow to fit Helm.Under the hood, it’s built in Go using the Helm v3 SDK. The architecture is an API server with workers pulling jobs from a PostgreSQL queue — no Kubernetes operator, just services talking directly to the Kubernetes API. Each preview runs in its own namespace with deny-all NetworkPolicies, ResourceQuotas, and LimitRanges. GitHub integration is done via a GitHub App for check runs and webhooks, with GitLab supported via the REST API.There were a few interesting challenges along the way. Injecting preview hostnames into Ingress resources without corrupting manifests took several iterations. Helm uninstall doesn’t always clean everything up, so deleting the entire namespace turned out to be the safest fallback. Handling rapid pushes to the same PR required build numbering so the latest push always wins. And while the Helm SDK is powerful, it’s under-documented — I spent a lot of time reading Helm’s source code.I’ve been building and testing this for a few months using real charts like Grafana, podinfo, and WordPress to validate the workflow. It’s early, but it works, and now I’m trying to understand whether other teams have the same pain point I did.You can try it by installing the GitHub App here: https://github.com/apps/chart-previewI’d love feedback on a few things:Does this solve a real problem for your team, or is shared staging “good enough”?What’s missing that would make you actually use it?Are there Helm charts this wouldn’t work for? (Cluster-scoped resources are intentionally blocked.)Happy to answer questions about the implementation.

Enrichment

Theme
Vertical
Horizontal
Function
Dev tools
Audience
Developer
AI stance
Not AI
Project type
Commercial product
Normalized one-liner
helm chart preview environments
Manually corrected
False

Could you build this?

Partial While the GitHub integration and Helm deployment scripts are straightforward, securely running arbitrary customer Helm charts in isolated preview environments requires advanced Kubernetes infrastructure.

What it would actually take: The architecture requires a control plane managing GitHub webhook events, coordinating dynamic cluster allocations via Kubernetes APIs, and orchestrating ingress/wildcard DNS routing. The hard part is sandboxing untrusted Helm charts to prevent privilege escalation or cluster exhaustion, demanding lightweight isolated clusters (e.g., vcluster or Firecracker microVMs) and granular network and storage policies.

Discussion

9 comments analyzed.

Competitors mentioned: ArgoCD with ephemeral previews, Helmfile, Flux, GitLab CI with custom pipelines

Concerns raised: Pricing concerns for third-party tool access, Security risk of granting cluster access to external service, GitHub-only, doesn't support self-hosted GitLab natively, Helm-only, no Kustomize or raw manifests support, Missing rendered manifest diff visibility

Feature requests: Native GitLab App integration with auto-triggering on MRs, Support for Kustomize and raw manifest deployment, Rendered manifest diff display tied to PR, GitOps integration (Flux/ArgoCD support), Manifest diff visualization before applying

Competitors

Other products that read as similar to this one — 53 launches clear the similarity bar, closest 8 shown.

Attention rank: #21 of 54 (itself plus its competitors, highest first — normalized so YC and Product Hunt are compared fairly).

Launched 51 days after the earliest competitor.

Other launches for this product

Same idea, different domain

Nobody's really built a dev tools tool for Sales yet.