Production-ready infrastructure for self-hosted web applications

Stack is an open-source, Kubernetes-native alternative to Heroku and Supabase. It gives you a database, auth, APIs, storage, and deployment as a single, self-hosted stack.

Install the Stack CLI

Download the CLI and bring the Stack platform into any Kubernetes cluster with a single command.

curl -fsSL https://stack-cli.com/install.sh | bash

One file. One stack. From laptop to production.

Stack CLI lets you define your entire web application stack in a single configuration file.

If you've used Docker Compose, this should feel familiar. There are no Helm charts to assemble and no manifests to glue together.

Run the same configuration locally using Docker Desktop’s built-in Kubernetes, then deploy it unchanged to production. What you develop against locally is what you run in production.

stack.yaml
apiVersion: stack-cli.dev/v1
kind: StackApp
metadata:
  name: bionic-gpt
  namespace: bionic-gpt
spec:
  components:
    ingress:
      port: 30010
    db:
    rest: {}
    auth:
      hostname-url: http://localhost:30013
      expose_admin: true
    storage:
      install_minio: true
  services:
    web:
      image: ghcr.io/bionic-gpt/bionicgpt:1.11.59
      port: 7703
      migrations_database_url: APP_DATABASE_URL
      init:
        image: ghcr.io/bionic-gpt/bionicgpt-db-migrations:1.11.59
        migrations_database_url: DATABASE_URL
        env:
          - name: INIT_MESSAGE
            value: "warming up"

The backend you'd build anyway—already wired

Every web application ends up needing the same backend pieces: a database, authentication, APIs, realtime, storage, and ingress.

Stack installs and wires these components per application namespace using proven open-source projects—so you don't spend weeks assembling charts, manifests, and glue code.

This is the setup most teams eventually arrive at—without the experimentation phase.

Included components
  • PostgreSQL with app-scoped credentials
  • Auth + OIDC via Keycloak
  • REST APIs via PostgREST
  • Realtime out of the box
  • Object storage via MinIO
  • Ingress + routing configured per app
Per app namespace

Each StackApp gets its own isolated set of backend services, so environments stay clean and predictable.

Local development that matches production

Stack works with Kubernetes you already have. Docker Desktop includes a built-in Kubernetes cluster, so you just flip it on and start developing.

The same StackApp you run locally can be deployed unchanged to staging and production. No separate compose files. No environment-specific rewrites.

Zero new tooling: use Docker Desktop, kubectl, and k9s, the tools you already know.
Same stack everywhere: Postgres, auth, REST, realtime, storage, and ingress behave the same locally and in production.
No platform gap: what works on your laptop works in the cluster.

Stack doesn't introduce a new runtime or control plane, it builds on standard Kubernetes so local and production stay aligned.

Using standard Kubernetes tools
k9s showing Stack-managed services running in Docker Desktop Kubernetes
Stack deploys standard Kubernetes resources. You inspect and operate them with kubectl, k9s, and existing tooling.

Cloud-agnostic by design

Stack is built on standard Kubernetes, so you're not locked into a specific cloud or provider.

For production, many developers run Stack on a simple VM using k3s, a lightweight Kubernetes distribution that's easy to set up and operate.

  • - Run on a single VM with k3s
  • - Move between providers without changing your config
  • - Lower cost than managed platforms
  • - Learn one stack that works everywhere
Learn it once. Run it anywhere.
Same configuration, different environments
Same configuration diagram