Ship products,
not plumbing.
One .stack/config.nix replaces dozens of config files. Reproducible dev environments, encrypted secrets, deterministic ports, and real HTTPS — generated for your whole team. No Nix knowledge required.
Apps
Deterministic ports · stack-aware tasks · live status
web
TanStack Start · Vite
api
Hono · Cloudflare Workers
queue-worker
Go · process-compose
Services
Postgres · Redis · Minio · Caddy + Step CA
PostgreSQL 16
Hashed from project name · isolated per-project
:4237
STACKPANEL_POSTGRES_PORT
Redis 7
Cache + pub/sub managed by process-compose
:4252
STACKPANEL_REDIS_PORT
Minio (S3)
Local object storage with presigned URLs
:4263
STACKPANEL_MINIO_PORT
Caddy + Step CA
Real HTTPS for *.myapp.local in dev
:4280
STACKPANEL_CADDY_PORT
Variables
SOPS + AGE · scoped per app and environment
DATABASE_URL
ref+sops://prod.sops.yaml#/DATABASE_URL
STACKPANEL_API_PORT
4201
VITE_PUBLIC_API_URL
https://api.myapp.local
AGE_RECIPIENTS
age1qd…ek7c, age1n4…tlkq, +2
1
config file
.stack/config.nix declares it all
Deterministic
ports
Hashed from project name
60+
agent endpoints
REST + Connect-RPC + SSE
Zero
vendor lock-in
Generated files look hand-written
How it works
Three planes, one project
Stackpanel runs as a Nix configuration, a local Go agent, and a web studio. Each plane has a clear job — together they replace the boilerplate that lives between your code and production.
01
Nix plane
Declarative source of truth
Evaluates your config, computes ports from your project name, provisions the devshell, and generates files. Runs once on shell entry.
- flake-parts + devenv adapter
- Per-app code generation
- SOPS recipients in Nix config
02
Local agent
Bridge to your environment
A Go binary on localhost:9876 that wraps Nix evaluation, manages services via process-compose, watches files, and serves the studio.
- REST + Connect-RPC + SSE
- JWT pairing flow
- Works fully offline
03
Web studio
Manage everything visually
A React app for browsing extensions, managing services, editing config, viewing generated files, and resolving secrets — without writing Nix.
- Real-time SSE updates
- Form-based config editor
- Per-extension panels
Git is the deploy target
Studio writes to your real config files. Diffs show up in code review like any other change.
Real-time, locally
SSE streams config and service updates from the agent — no polling, no cloud round-trips.
Eject without migration
Generated files live in standard locations. Stop using Stackpanel and your repo keeps working.
Platform
Everything that lives between code and production
Stackpanel collapses the dozens of files, services, and integrations every team rebuilds from scratch into a single declarative configuration.
Reproducible devshells
flake.lock pins every package, runtime, and version. Every teammate gets the exact same Node, Bun, Go, Postgres — independent of their OS.
Deterministic ports
Ports are hashed from your project name, then sequenced for apps and services. Same ports on every machine, no .env coordination, no clashes between projects.
Service orchestration
Postgres, Redis, Minio, Caddy, and Step CA managed by process-compose. One command to start the whole stack with health probes wired up.
Encrypted secrets
SOPS-encrypted YAML with AGE recipients declared in Nix. Add a teammate's public key, run rekey, commit the diff. No external KMS to manage.
Real HTTPS in dev
Step CA issues internal certificates and Caddy reverse-proxies your apps to https://*.local — no browser warnings, no self-signed cert wrangling.
IDE auto-config
VS Code and Zed workspace settings, recommended extensions, and devshell loaders are generated and committed. New hires open the repo and the editor is ready.
Type-safe @gen/env
Per-app codegen turns your secret schemas into typed TypeScript modules with embedded encrypted payloads. Import from @gen/env/<app> and ship.
Extension registry
Browse extensions in the studio and enable them with one click. Stackpanel writes the Nix config for you and contributes generated files, scripts, and panels.
No vendor lock-in
Generated files are standard config in standard locations. Stop using Stackpanel and the repo keeps working — there is nothing to migrate.
One config, everything generated
Declare your stack once.
A single .stack/config.nix describes your apps, services, secrets, ports, IDE settings, and deployment. Everything else — the dotfiles, the Caddyfile, the SOPS rules, the type-safe env modules — is build output.
{ pkgs, ... }: {stackpanel = {enable = true;name = "myapp";# Apps get sequential ports from the hashed baseapps = {web = { port = 0; }; # → :4200api = { port = 1; }; # → :4201};# Background services managed by process-composeglobalServices = {enable = true;postgres.enable = true;redis.enable = true;minio.enable = true;};# Real HTTPS for *.myapp.localcaddy.enable = true;step-ca.enable = true;# Editor settings + extensions, generated for the teamide = {enable = true;vscode.enable = true;zed.enable = true;};# SOPS recipients live in Nixsecrets.recipients = config.stackpanel.users.allKeys;# Project commands available on $PATHscripts.dev = {exec = "bun run --filter './apps/*' dev";description = "Start every app in dev mode";};};}
Don't want to write Nix? Open the studio — every option has a form, and changes are written back to this file.
The dotfiles you would have written by hand.
Generated files live where every tool expects them, in formats every teammate already knows. Studio shows you which files are stale, which module wrote them, and what would change if you regenerated.
.vscode/settings.json
Workspace settings + recommended extensions for VS Code
.zed/settings.json
Language server config + Nix integration for Zed
.stack/secrets/.sops.yaml
SOPS creation rules rendered from declared recipients
packages/gen/env/src/<app>.ts
Type-safe env modules per app with embedded payloads
.stack/state/stack.json
Resolved ports, URLs, services for the Go agent
.stack/gen/process-compose.yaml
Service definitions with health probes and dependencies
.vscode/launch.json
Debug configurations contributed by app modules
Caddyfile
Reverse-proxy routes for *.local hostnames with TLS
Local infrastructure
Production-shaped services on your laptop.
Stackpanel runs the same data stores you use in production — Postgres, Redis, MinIO — orchestrated by process-compose with health probes and dependency ordering.
Caddy and an internal Step CA give you real HTTPS at clean hostnames like https://api.myapp.local — so OAuth, secure cookies, and webhooks behave like prod.
Modules can target NixOS or container runtimes for staging and production. Same config language, same generated Caddyfile, same SOPS recipients — different host.
PostgreSQL
Local cluster with persistent data dir, ready for migrations.
Redis
Single-node cache for sessions, queues, and rate limits.
MinIO
S3-compatible object storage with admin console exposed.
Caddy
Reverse proxy that wires *.local hostnames to your apps.
Step CA
Internal certificate authority — real HTTPS in dev, no warnings.
process-compose
Health probes, dependencies, and restart policies for everything above.
Production stacks
Deploy without becoming a platform team.
Production Stacks are maintained Nix flake inputs that take your app from .stack/config.nix all the way to production. Stick to the conventions and you should never need more than one option flip.
Alchemy
Stable · maintained
Resource-graph IaC for the full TypeScript stack — Cloudflare, AWS, Vercel.
# .stack/config.nixapps.web = {framework = "nextjs";alchemy = {target = "cloudflare"; # or "aws" | "vercel"previews = true;};};
- Type-safe bindings generated into your app
- Per-PR preview environments out of the box
- Secrets pulled straight from .stack/secrets
- State stored in your repo or your S3 bucket
Colmena
Stable · maintained
NixOS deploys for the people who want full control — Hetzner, bare metal, your own racks.
# .stack/config.nixapps.api = {colmena = {host = "cax21.fra";replicas = 2;rollback.enable = true;};};
- Atomic switch with one-command rollback
- Machine groups for canary + production fleets
- Secrets via agenix, recipients managed in Nix
- Caddy + Step CA wired identically to dev
Fly.io
Stable · maintained
Containerized apps at the edge — regional placement, Fly volumes, Fly Postgres.
# .stack/config.nixapps.api.fly = {regions = [ "iad" "fra" "sin" ];machines = 3;postgres.cluster = "myapp-pg";autoscale.maxMachines = 10;};
- Multi-region machines from one Nix config
- Health probes, autoscale, and graceful drain
- Fly secrets sync from .stack/secrets at deploy
- Built-in observability via Fly Metrics
You write the convention. We keep it green.
Stacks are versioned Nix flake inputs. Subscribers get the private stable channel and a maintenance commitment — same-day patches, tested against every nixpkgs and provider API change.
Same-day patches when nixpkgs ships breaking updates
Tested against every flake.lock bump before release
Provider API drift handled before it breaks your deploys
Marketplace coming soon
Third-party creators can ship and sell their own Production Stacks — Stackpanel takes 20%, you keep 80%.
Solo developers always have free access to the community branch of every stack.
Developer experience
Onboarding measured in minutes, not days.
The README on most repos starts with a 14-step setup guide. Stackpanel replaces it with direnv allow — and a teammate is running the full stack on the same ports as everyone else.
- 1
$ git clone …
Pull the repo as usual
- 2
$ direnv allow
Devshell builds in the background
- 3
$ dev
Apps + services come up; studio opens
Onboarding without docs
git clone, direnv allow, done. Devshell installs every runtime, generates IDE settings, drops scripts on $PATH, and opens the studio.
Real URLs, real ports
Hit https://web.myapp.local in any browser. OAuth callbacks, secure cookies, and webhooks behave the same as in production.
Secrets that just work
Add a teammate's AGE key, rekey the SOPS files, commit the diff. Their next direnv reload pulls the new keys with zero config.
Project commands on $PATH
Declared scripts (dev, lint, test, deploy) become real binaries. Every teammate runs the same command — no per-shell aliases.
CLI
Real commands, no proprietary glue
The stackpanel CLI speaks Nix, SOPS, and process-compose. Every command operates on standard files in your repo.
Same command works on macOS, Linux, and NixOS — same versions, same output.
Comparison
Why not just use what we already have?
Each of these tools solves part of the problem. Stackpanel composes them — so you stop maintaining the glue.
| Capability | StackpanelOpen source | Raw Nix / devenvDIY | Docker ComposeContainer-only | Hosted PaaSVercel · Render · Fly |
|---|---|---|---|---|
Reproducible across machines Same Bun, Go, Postgres versions | ||||
Deterministic shared ports Same ports on every laptop | ||||
Real HTTPS in dev Internal CA + reverse proxy | ||||
Encrypted secrets in repo SOPS + AGE recipients in Nix | ||||
Type-safe env per app Generated TS / Go / Python | ||||
IDE settings & extensions VS Code + Zed, version-controlled | ||||
Visual studio for the team Web UI for non-Nix users | ||||
Maintained deployment recipes Production Stacks updated for you | ||||
No vendor lock-in Eject and the repo still works | ||||
Self-hosted Runs on your laptop and your cloud |
Comparison reflects out-of-the-box behavior on a fresh repo. Most stacks can replicate parts of Stackpanel with enough custom tooling — that's the tooling we're replacing.
Pricing
Free dev environment. Paid production support.
The Stackpanel core is MIT and free forever. Subscribe when you're ready to outsource the maintenance of your production deploys to a team that does it full-time.
Community
Solo dev. Free forever.
$0
1 seat · no card required
- Stackpanel core (MIT)
- All 3 stacks on community branch
- Best-effort patches
- GitHub Discussions support
Team
Most popularFor shipping teams.
$19
per user / month, billed monthly
- Everything in Community
- Stable branch of every Production Stack
- 30-day patch SLA
- Email support, next business day
Business
For platform teams.
$49
per user / month, billed monthly
- Everything in Team
- 7-day patch SLA + early access channel
- Multi-org, SSO, audit logs
- Discord channel + 4-hour email response
Enterprise
For companies that ship the world.
Custom
from $5,000 / month
- 24-hour critical CVE SLA
- Air-gapped mirror license
- Slack channel, on-call, named CSM
- Indemnification, SCIM, custom RBAC
Same Production Stacks across every tier. You pay for SLA, support, and team features — not for access to the recipes.
Compare every featureReserve your spot in the beta.
Stackpanel core ships free for everyone. Production Stacks land as managed subscriptions on top. Join the beta to get early access to both, plus a direct line to the team building it.
Step 1
nix flake init -t …
Step 2
direnv allow
Step 3
dev
Prefer to read first? Browse the docs