Budibase on Debian 12 (Docker Compose + CouchDB + Redis + SSL)
Budibase is an open-source low-code platform that enables developers and teams to rapidly build internal tools, dashboards, and business apps with minimal code. It provides a visual builder, data connectors, user authentication, and automation — making it ideal for companies that want to create custom internal applications, admin panels, or workflows quickly and securely.
Running Budibase on Debian 12 (Bookworm) with Docker Compose offers a stable, long-term supported, and production-ready foundation. Debian 12’s modern stack — including systemd 252, OpenSSL 3, and updated Docker support — ensures excellent performance, compatibility, and security for hosting Budibase with SSL and reverse proxy integration.
Architecture Overview
| Layer | Component | Role |
|---|---|---|
| OS | Debian 12 (Bookworm) | Stable, secure Linux base with long-term support |
| Container Runtime | Docker Engine + Compose | Orchestrates Budibase and dependent services |
| Database | CouchDB / PostgreSQL (optional) | Stores app data, configurations, and users |
| Cache Queue | Redis | Handles caching, background jobs, and sessions |
| Backend | Budibase Server | Processes API requests and automation workflows |
| Frontend | Budibase Web UI | Provides the app builder and admin interface |
| Reverse Proxy | Nginx (optional) | TLS termination, routing, caching, and compression |
| TLS | Let’s Encrypt / PKI | Provides secure HTTPS connections for all web traffic |
Why Use Budibase?
- Low-code development – create fully functional apps without writing complex code.
- Open-source – free to host and modify on your own infrastructure.
- Rapid deployment – build and publish internal tools in minutes.
- Integration-ready – connect to external databases, APIs, or spreadsheets.
- Role-based access – manage users, permissions, and authentication easily.
- Self-hosted – maintain complete data privacy and control.
Budibase vs Other Low-Code Platforms
| Feature/Capability | Budibase (Self-hosted) | Retool (Cloud) | Appsmith (Self-hosted) | ToolJet (Self-hosted) |
|---|---|---|---|---|
| Hosting | Self-hosted (Docker) | SaaS only | Self-hosted | Self-hosted |
| Cost | Free, open-source | Subscription-based | Free + enterprise tier | Free + enterprise tier |
| Database options | CouchDB / PostgreSQL | External only | PostgreSQL / MongoDB | PostgreSQL / MongoDB |
| Authentication | Built-in | External (OAuth) | Built-in | Built-in |
| Extensibility | High (custom plugins) | Moderate | High | High |
Budibase excels as a self-hosted, extensible, and low-cost alternative to commercial low-code platforms — ideal for teams that value agility and data control.
Security & Best Practices
- Run Budibase behind Nginx with HTTPS enabled.
- Keep
.envand credentials secure — never commit them to version control. - Use Docker secrets for database passwords and API keys.
- Restrict access to CouchDB/Redis using Docker’s internal network.
- Schedule automated backups for CouchDB or PostgreSQL.
- Keep Docker and Debian packages updated regularly.
- Use UFW or nftables to limit public access to ports 80/443 only.
- Automate SSL certificate renewals with Certbot or Traefik ACME.
Typical Use Cases
- Internal tools for managing HR, finance, or logistics workflows.
- Dashboards connected to databases or REST APIs.
- Customer portals and access panels.
- Workflow automation integrated with third-party apps.
- Rapid prototyping of business apps and operational tools.
Deploying Budibase on Debian 12 with Docker Compose gives you a secure, scalable, and open-source low-code platform that empowers your team to build custom internal tools and automate processes — without relying on costly SaaS services.
Step 1: Create a Server Instance on Shape.Host
Before you begin, create your Debian 12 server:
Log into your Shape.Host dashboard.
Click Create → Instance.

Choose a data center location close to your users.

Select a plan with at least 2 CPUs, 4 GB RAM, and 20 GB SSD (recommended for Budibase).
Pick Debian 12 (64-bit) as the operating system.

Click Create Instance.

Once your instance is active, note the public IP address from the Resources section.

Step 2: Connect to Your Instance
- Linux/macOS users:
ssh root@your_server_ip - Windows users (PuTTY):
- Open PuTTY.
- Enter your instance’s IP address.
- Click Open and log in with your Shape.Host credentials.
Step 3: Install Docker and Docker Compose
Update system packages:
apt update
Install required dependencies:
apt install ca-certificates curl gnupg lsb-release

Create a secure directory for Docker’s GPG key:
install -m 0755 -d /etc/apt/keyrings
Add Docker’s official GPG key:
curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg
Set proper file permissions:
chmod a+r /etc/apt/keyrings/docker.gpg
Add the Docker repository:
echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
$(lsb_release -cs) stable" \
> /etc/apt/sources.list.d/docker.list
Update repositories again:
apt update

Install Docker Engine and the Compose plugin:
apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin

Enable and start the Docker service:
systemctl enable --now docker
Verify Docker Compose installation:
docker compose version
You should see the version output confirming it’s installed and working.
Step 4: Create the Budibase Directory
Create a dedicated directory for your Budibase setup:
mkdir /opt/budibase
Move into that directory:
cd /opt/budibase

Step 5: Create the Docker Compose Configuration
Open a new configuration file:
nano docker-compose.yml
Paste the following content:
services:
couchdb:
image: couchdb:3
restart: always
environment:
COUCHDB_USER: admin
COUCHDB_PASSWORD: change_this_password
volumes:
- couchdb:/opt/couchdb/data
minio:
image: minio/minio
restart: always
environment:
MINIO_ROOT_USER: minioadmin
MINIO_ROOT_PASSWORD: change_this_password
command: server /data
volumes:
- minio-data:/data
redis:
image: redis:7
restart: always
budibase:
image: budibase/budibase:latest
restart: always
depends_on:
- couchdb
- redis
- minio
ports:
- "80:80"
environment:
BB_ADMIN_USER: admin@admin.com
BB_ADMIN_PASSWORD: admin
COUCHDB_URL: http://admin:change_this_password@couchdb:5984
REDIS_URL: redis://redis:6379
MINIO_ENDPOINT: minio
MINIO_ACCESS_KEY: minioadmin
MINIO_SECRET_KEY: change_this_password
MINIO_USE_SSL: "false"
volumes:
couchdb:
minio-data:
Explanation of services:
- CouchDB — Database for Budibase app data.
- MinIO — Object storage for uploads and assets.
- Redis — Caching and session management.
- Budibase — Main web application service.
⚠️ Replace all instances of
change_this_passwordwith strong, unique passwords.
Save and exit the editor with CTRL + O, then CTRL + X.

Step 6: Start Budibase with Docker Compose
Pull the required Docker images:
docker compose pull


Run Budibase in detached mode:
docker compose up -d

Verify that all containers are running:
docker compose ps
If everything is “Up,” your Budibase setup is live.

Step 7: Access the Budibase Web Interface
Open your browser and navigate to:
http://YOUR_SERVER_IP
Log in using:
- Email:
admin@admin.com - Password:
admin
After logging in, you can change your password and start building internal tools and apps.



Step 8 (Optional): Secure Your Setup with HTTPS
If you have a domain name, you can easily enable HTTPS with Let’s Encrypt:
apt install python3-certbot-nginx
certbot --nginx -d yourdomain.com
Follow the prompts to automatically generate and apply SSL certificates.
You’ve successfully installed Budibase on Debian 12 using Docker Compose.
This setup provides a powerful and modular environment ready for building custom internal tools, dashboards, and apps with minimal effort.
For better uptime, performance, and scalability, deploy your Budibase server on a Shape.Host Cloud VPS — optimized for Docker-based applications and long-term stability.