Deploy Your Own AI Agent Platform in 20 Minutes: The AACFlow Self-Hosting Story

Independence. No vendor can shut down your automation because they changed their pricing, pivoted their product, or went out of business. You run the code. You own the deployment.

The Architecture: Docker Compose Everywhere

AACFlow is defined as a set of Docker Compose services:

That's the entire infrastructure. Three services (PostgreSQL, Redis, AACFlow) plus an optional Socket.IO server. No Kubernetes. No service mesh. No distributed consensus algorithms. Just the minimum set of components needed to run a production AI agent platform.

Choosing the Stack for Deployability

Every technology choice we made was filtered through the lens of self-hosting:

PostgreSQL, not a managed database service. Anyone can run PostgreSQL. It has 30 years of operational knowledge behind it. pgvector adds vector search without adding another database.

Redis, not a managed message queue. Redis is trivial to deploy. It handles caching, sessions, Pub/Sub, and rate limiting — four concerns, one service.

Bun, not a complex Node.js setup. Bun bundles TypeScript natively. No build step. No webpack config. The Dockerfile is 15 lines.

Better Auth, not a SaaS auth provider. Authentication runs inside the application, not in someone else's cloud. No vendor dependency for the most critical security boundary.

Drizzle ORM, not a managed database platform. Migrations are SQL files. They run at startup. No external migration service needed.

Every "managed cloud service" we could have used would have made development easier but self-hosting harder. We chose the harder path — and our users get the benefit.

Coolify: The One-Click Deploy

While our Docker Compose files work anywhere, we've optimized the deployment experience for Coolify — an open-source, self-hosted Platform-as-a-Service.

With Coolify, deployment is:

1. Connect your server — Coolify SSHes in and installs Docker
2. Point to your Git repository — Coolify pulls the code
3. Set environment variables — database URLs, API keys, secrets
4. Click deploy — Coolify builds the Docker image and starts the containers

After the initial deploy, Coolify handles:

• Automatic updates — webhook-triggered redeploys on every push to main
• Rollbacks — one-click revert to any previous deployment
• SSL certificates — automatic Let's Encrypt provisioning and renewal
• Health checks — container monitoring with automatic restart on failure
• Backups — scheduled database dumps to S3-compatible storage

Twenty minutes from empty server to running AI agent platform. Not a marketing promise. We've timed it.

The Dockerfile: Lean and Fast

Our production Dockerfile is intentionally minimal:

No multi-stage builds with separate build and runtime images (yet — it's on the roadmap). No Alpine-based distroless optimization. Just a straightforward, understandable Dockerfile that anyone can audit and modify.

The Dockerfile.dev for local development adds hot reload, debug ports, and development dependencies. But the production file stays simple: install, build, run.

Environment Configuration: Twelve-Factor Style

All configuration lives in environment variables. One .env file controls the entire platform:

No config files. No XML configuration. Nothing that requires a restart to change (except secrets, for security). This is the Twelve-Factor App methodology applied to AI infrastructure.

Backup and Disaster Recovery

Self-hosting means you're responsible for your own backups. We make that easy:

Database backups. A cron job in the Coolify UI runs pg_dump nightly and uploads to S3-compatible storage. Restore is a single pg_restore command.

Volume backups. Redis data (session state, collaboration state) is backed up alongside PostgreSQL. While Redis is primarily a cache, active collaboration sessions are valuable enough to back up.

Configuration backups. The .env file and Docker Compose configuration live in Git. "Infrastructure as code" means your deployment definition is version-controlled alongside your application code.

Disaster recovery time. From a catastrophic server failure to a fully restored platform: 30 minutes. Spin up a new server, run the Coolify setup, restore the database backup, deploy the latest commit. Done.

Enterprise Private Cloud

For organizations that need maximum isolation, we offer private cloud — a single-tenant deployment in the customer's own VPC:

• Dedicated PostgreSQL instance (not shared with other tenants)
• Dedicated Redis instance
• VPN or VPC peering for secure connectivity
• Customer-managed encryption keys
• Optional: air-gapped deployment (no outbound internet — models provided via local API)

Private cloud isn't a separate codebase. It's the same Docker Compose stack, deployed on the customer's infrastructure, with additional network isolation. We make money by providing the best platform for agents, not by holding onto your data.

What We Learned

Docker Compose is good enough for 99% of deployments. Kubernetes is powerful but complex. For a platform serving tens of thousands of users, Docker Compose with proper monitoring is simpler, more reliable, and easier to debug.

One database is better than five. PostgreSQL handles relational data, vector search (pgvector), and JSON documents. We don't need MongoDB, Pinecone, and a separate analytics database. Fewer moving parts means fewer failure modes.

Self-hosting changes your engineering priorities. When users run your code on their own infrastructure, you can't rely on "we'll fix it on our servers." Error messages must be clear. Logs must be comprehensive. Configuration must be well-documented. The platform must degrade gracefully.

Coolify is a force multiplier. Without it, self-hosting would require users to understand Docker networking, SSL termination, reverse proxies, and container orchestration. Coolify abstracts all of that behind a clean UI. We contribute back to the project because it enables our entire deployment model.

What's Next

• Kubernetes Helm chart — for organizations that already run K8s and want native integration
• Terraform module — infrastructure-as-code for the entire AACFlow stack
• Monitoring stack — pre-configured Grafana + Prometheus dashboards for self-hosted deployments
• Air-gapped mode — full offline deployment with local model serving via Ollama
• Automated migration testing — CI pipeline that tests upgrades from every previous version

Try It Yourself

The Docker Compose files are in our GitHub repository. The Coolify setup guide is in our docs. If you have a server (or even a powerful laptop) and 20 minutes, you can run your own AI agent platform.

No lock-in. No vendor dependency. No "trust us" — just code you can read, run, and verify.

— Alexandr Chibilyaev