How to Install Budibase on Debian 12 Using Docker Compose

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 .env and 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.

Shape.host instance form with the data center location selector highlighted.

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.

Shape.host instance form with the operating system image selector highlighted.

Click Create Instance.

Shape.host instance form with the Create Instance button highlighted.

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

Shape.host Resources dashboard with the server IP address highlighted.

Step 2: Connect to Your Instance

Linux/macOS users: ssh root@your_server_ip
Windows users (PuTTY):
1. Open PuTTY.
2. Enter your instance’s IP address.
3. 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

Terminal showing APT package management commands and output.

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

Terminal showing the installed Docker Compose version.

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_password with strong, unique passwords.

Save and exit the editor with CTRL + O, then CTRL + X.

Terminal showing application configuration fields.

Step 6: Start Budibase with Docker Compose

Pull the required Docker images:

docker compose pull

Terminal showing container image download progress.

Terminal displaying Budibase container image download progress.

Run Budibase in detached mode:

docker compose up -d

Terminal showing Docker Compose image downloads and container startup output.

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

Email: admin@admin.com
Password: admin

After logging in, you can change your password and start building internal tools and apps.

Budibase administrator account creation form.

Budibase table and data source controls.

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.