$ cat bunnyshell.yaml

One File.
Every Stack. Zero Drift.

Define your entire stack in one file. Version-controlled.
Reproducible. Drift-free.

No credit card required

B
Environments / my-app / bunnyshell.yaml
1  kind: Environment
2  name: my-app-{{ env.unique }}
3  components:
4    - kind: DockerCompose
5      name: frontend
6    - kind: Helm
7      name: api
8      dependsOn: [database]
9    - kind: Terraform
10    name: database
Valid 5 components · 3 types
How Bunnyshell works — architecture diagram

$ cat how-it-works.md

How Bunnyshell works

01

Connect your repo

Link your GitHub, GitLab, or Bitbucket repository. Define your environment using Docker Compose, Helm, or Terraform — tools you already use.

GitHubGitHub
GitLabGitLab
BitbucketBitbucket
DockerDocker
HelmHelm
K8sK8s
02

Open a pull request

Bunnyshell auto-provisions an isolated, full-stack environment for every PR. Share the preview URL with your team.

PR #142env-142.preview.bunnyshell.dev• Running
PR #143env-143.preview.bunnyshell.dev• Running
PR #144env-144.preview.bunnyshell.dev• Running
03

Merge and move on

Tests pass, code is reviewed, PR merges. The environment auto-destroys. No cleanup. No surprise cloud bills.

End-to-end tests passed
Code review approved
Merged — environment destroyed

See it in action.

Define your first environment in under 30 minutes. Free trial — no credit card required.

01

Your Entire Stack,
In One YAML File.

Docker Compose services, Helm charts, Kubernetes manifests, Terraform modules — all defined in a single bunnyshell.yaml that lives in your repo. Push to Git and your environment rebuilds exactly as defined. Every time.

  • Declarativedescribe the desired state, Bunnyshell handles the execution
  • Version-controlledevery change to your environment is a Git commit with full audit trail
  • Reproduciblesame YAML, same environment. Dev, staging, production — identical
  • Composablemix Docker Compose, Helm, Terraform, and K8s manifests in a single definition
See configuration docs
B
Environments / my-app / bunnyshell.yaml
1  kind: Environment
2  name: my-app-{{ env.unique }}
3  components:
4    - kind: DockerCompose
5      name: frontend
6    - kind: Helm
7      name: api
8      dependsOn: [database]
9    - kind: Terraform
10    name: database
Valid 5 components · 3 types
02

7 Component Types.
One File.

Your stack isn't one thing. It's a frontend in Docker Compose, a backend in Helm, infrastructure in Terraform, and a worker running raw manifests. Bunnyshell handles all of them — in a single environment definition.

  • Docker Composeauto-converted to Kubernetes. Health checks, volumes, cron jobs, ingress — all translated
  • Helmdeploy Helm charts with full lifecycle management. Custom values, rollback, atomic installs
  • Terraformprovision cloud resources as part of your environment. RDS, S3, Cloud SQL — anything Terraform manages
  • Kubernetes Manifestsapply raw K8s YAML directly. No abstraction overhead
See component types docs
B
Environments / my-app / Components
DockerCompose2 active
Helm1 active
KubernetesManifest1 active
Terraform1 active
CustomDockerImageavailable
StaticAppavailable
Generic1 active
03

Dependency
Orchestration.

Your API needs the database. Your worker needs the API. dependsOn declares the order. Bunnyshell builds a dependency graph, deploys independent components in parallel, and waits for dependencies before deploying downstream services.

  • Declarative orderingdependsOn: [database, cache] and Bunnyshell does the rest
  • Parallel executioncomponents without dependencies deploy simultaneously
  • Cross-component references{{ components.database.exported.DB_HOST }} wires services together
  • Cascading destroystear down in reverse dependency order. Clean, every time
See dependency docs
B
Environments / my-app / Deploy Pipeline
Resolving dependency graph…
database    (Terraform) deployed
cache       (K8s Manifest) deployed
api         (Helm) depends: [database, cache]
frontend    (DockerCompose) waiting on api
worker      (Generic) depends: [api, database]
Parallel: database + cache · Sequential: api → frontend
04

Variables, Secrets
& Interpolation.

Twig-like expression engine with conditionals, filters, and cross-component references. Wire outputs from one component into another. Config adapts to every environment automatically — no hard-coded strings.

  • Twig-like expressionsfilters, defaults, and conditionals for environment-specific behavior
  • Cross-component referenceswire outputs from one component to inputs of another automatically
  • Secret variablesencrypted at rest, injected at deploy time. Never hard-coded
  • Variable Groupsshare secrets across environments. Override per-env when you need to
See variables docs
B
Environments / my-app / Variables
# Cross-component reference
db.host: {{ components.database.exported.DB_HOST }}
# Secret injection
db.password: {{ secret.DB_PASSWORD }} 🔒 encrypted
# Default with filter
instance: {{ env.vars.DB_SIZE|default('db.t3.micro') }}
# Conditional
debug: {{ env.vars.DEBUG == "true" ? "--debug" : "" }}
12 variables 3 secrets · 2 groups
05

Template Sync
& Drift Detection.

UI changes and YAML edits diverge over time. Template Sync detects the difference automatically and shows a side-by-side diff — reconcile or override in one click.

  • Drift detectionautomatic comparison between environment state and YAML source of truth
  • Side-by-side diff editorsee exactly what changed, decide what to keep
  • One-click reconciliationapply the template to bring the environment back in line
  • Audit trailevery change tracked in Git. Who changed what, when, and why
See template sync docs
B
Environments / my-app / Template Sync
Drift detected3 changes found
- Environment (current)
replicas: 3
image: api:v1.2.0
memory: 512Mi
+ Template (YAML)
replicas: 2
image: api:v1.3.0
memory: 1Gi
Apply TemplateKeep Current

Built for every team member,
not just DevOps.

Developers

One file, one truth

One YAML file, one command, one environment. Every dependency version, every connection string — defined in code, not tribal knowledge.

Platform Teams

Enforce standards in code

Define approved templates in Git. Every team gets compliant environments without tickets or runbooks.

New Hires

Day-one productivity

Clone the repo, deploy from the template. A working environment in minutes — ready to contribute from day one.

QA Engineers

Identical test environments

Same YAML, same environment. Dev, staging, QA — all built from the same definition. Reproducible by default.

Engineering Leaders

Full visibility across environments

Version-controlled environments with template sync and drift detection. Know exactly what is running, everywhere.

Solution Architects

Multi-stack, one definition

Docker Compose, Helm, Terraform, K8s manifests — all in one file. No more separate pipelines for each stack.

Same YAML. Same environment. Every time.

Define your stack, deploy, and see reproducible environments in action. Free trial, no credit card required. Free white-glove onboarding.

Teams that eliminated
environment drift.

Enterprise-grade security.
Your data stays in your cloud.

Bunnyshell connects to YOUR Kubernetes cluster. Your code and data never leave your infrastructure. SOC 2, ISO 27001, and ISO 9001 compliant.

SOC 2
ISO 27001
ISO 9001

RBAC

Three-layer permission model: Policies, Resource Selectors, and Teams. Granular enough for enterprise.

SSO

Enterprise single sign-on. Integrate with your existing identity provider.

Network Isolation

Dedicated Kubernetes namespace per environment. Pods accessible only within their namespace.

Secrets Management

Environment variables and secrets handled securely. Never hard-coded, always encrypted.

IP Whitelisting

Restrict access to specific IP ranges. Control who can reach your environments.

Audit Logs

Full audit trail for every environment action. Who deployed what, when, and where.

Frequently asked
questions

Can’t find what you’re looking for? Talk to our team

It's a declarative configuration file that defines your entire environment — application services, databases, infrastructure, dependencies, variables, and hosts. Think of it as a docker-compose.yml that also handles Helm charts, Terraform modules, and Kubernetes manifests in a single file.

Define once. Deploy everywhere.

Write your bunnyshell.yaml and deploy reproducible environments in minutes. Free trial, no credit card required. Free white-glove onboarding.