Backstage Helm Chart
A backstage helm chart packages your developer portal so you can run it on Kubernetes. You deploy the chart by setting up your image, database credentials, and cluster roles. Most teams start by giving the portal pod broad cluster and database roles. That fast setup works on day one, but it creates big security risks later. If an attacker or bad plugin abuses that pod, it has full cluster permissions. Teams need a clear plan to scope down roles and protect backend data. How a backstage helm ch
Your coding agents run with your access.
Claude Code reaches prod with a developer's credentials, and approval prompts get clicked through. hoop.dev checks every query, masks sensitive data, and holds risky changes for a human.
A backstage helm chart packages your developer portal so you can run it on Kubernetes. You deploy the chart by setting up your image, database credentials, and cluster roles. Most teams start by giving the portal pod broad cluster and database roles. That fast setup works on day one, but it creates big security risks later. If an attacker or bad plugin abuses that pod, it has full cluster permissions. Teams need a clear plan to scope down roles and protect backend data.
How a backstage helm chart deployment works
When you install a backstage helm chart, Kubernetes creates pods, services, and secret mounts. The chart reads your custom values to link the portal to a backend database. Most teams use a managed PostgreSQL instance to store the software catalog and user state. The chart can also spin up a local database pod for quick testing.
To show live cluster data, the portal needs a Kubernetes service account. You bind this service account to a role inside your target clusters. The portal uses that role to read pod status, logs, and deployment health. You also pass API keys into the pod through Kubernetes secrets. These keys let plugins talk to source control, ticket boards, and cloud accounts.
Traffic enters the cluster through an ingress controller that routes requests to the portal service. Users log in through an identity provider like Okta, GitHub, or Google. Once inside, the portal maps each user to a group in the software catalog. That group decides which pages and buttons the user can see in the web app.
Why native chart roles leave a security gap
Native chart settings help you get the portal running and check who logs in. Role bindings inside the portal can hide a button or block a page view. Still, the chart setup only controls initial sign-in and basic Kubernetes pod permissions. It does not inspect what individual database queries or cluster commands do in flight.
When an engineer runs a task or checks data, the pod uses shared backend keys. The target database only sees the shared portal user, not the human who clicked. If a developer gets direct database credentials for debugging, the chart cannot restrict their queries. One bad query can drop a catalog table or return sensitive fields like emails. Native roles decide who enters the room, not what actions they run inside.
Static secrets inside the chart values also create rotation pain for platform teams. Every time you rotate a database password, you must update secrets and restart pods. Teams often skip rotation because they fear breaking the developer portal during work hours. Over time, those long-lived keys end up copied into local files and test scripts.
Helm Chart Security + Backstage Security Plugins: architecture patterns and best practices
Continue reading? Get the full guide.
Free. No spam. Unsubscribe anytime.
Best practices for securing your portal setup
Start by turning off the built-in database subchart for any real team deployment. Point the portal at an external PostgreSQL service with regular backups and strict network rules. Give the portal database user permission to read and write only its own schemas.
Next, review the Kubernetes role bound to the portal service account. Never bind the pod to a cluster admin role just to make plugins work. Grant read-only rules for specific namespaces and resource types like pods and deployments. Store all cloud tokens and app secrets in an external secret store, not plain text.
Finally, separate how your portal reads state from how engineers run live changes. Use the portal to view catalog info and trigger safe, pre-built pipelines. When engineers need direct database sessions or kubectl commands, check every request in flight. Masking rules can rewrite matched fields like card numbers or phone numbers in query results.
Add request guardrails and response masking beside Kubernetes
Cluster roles and service accounts govern who reaches the Kubernetes API. Still, a broad role or agent can delete workloads or print sensitive values from ConfigMaps and logs. In practice, hoop.dev sits inline beside the API server as a sidecar for your Kubernetes API. For every production API call an agent or human sends, hoop.dev decides whether to pass, mask, block, or escalate it for review alongside RBAC.
With hoop.dev Kubernetes controls, guardrails allow listing Secret names while refusing reads of Secret data before execution, and data masking redacts matched keys in returned JSON responses and log streams in memory. Furthermore, hoop.dev holds SOC 2 Type II and is MIT licensed on GitHub.
Frequently asked questions
Should I use the built-in PostgreSQL subchart in production?
No, the built-in database subchart is best for local tests and quick demos. For production, connect your deployment to a managed PostgreSQL service with automated backups.
How do I pass API tokens to plugins safely?
Do not put raw tokens into your versioned chart values files. Create Kubernetes secrets from an external secret manager and mount them as environment variables.
What Kubernetes permissions does the portal service account need?
The service account only needs read permissions for resources shown in your catalog views. Scope the role to specific namespaces and block write access to secrets and roles.
Related guides
In this post