Budibase vs Appsmith vs ToolJet: Best Self-Hosted Low-Code Platforms 2026

Building internal tools, admin panels, and business applications no longer requires a full engineering team. Low-code platforms let you connect databases, design UIs, and deploy applications through visual interfaces. But relying on SaaS low-code providers means your data flows through third-party servers, your pricing can change overnight, and your apps disappear if the company shuts down.

Self-hosting a low-code platform gives you the speed of visual development with full data sovereignty, unlimited users, and zero per-seat licensing fees. This guide compares the three leading open-source, self-hosted low-code platforms — Budibase, Appsmith, and ToolJet — with Docker deployment instructions so you can run any of them on your own infrastructure today.

Why Self-Host a Low-Code Platform

The case for self-hosting your low-code infrastructure rests on five pillars:

Data sovereignty: Internal tools interact with your most sensitive data — customer records, financial reports, operational metrics. A self-hosted platform ensures that data never leaves your network. All database connections, API calls, and query results stay within your infrastructure.

No per-seat pricing: SaaS low-code platforms typically charge $10–$50 per user per month. Once you have dozens of team members needing access, those costs explode. Self-hosted platforms impose no user limits — invite your entire organization.

Unlimited apps: Cloud platforms restrict how many applications you can build on free or lower tiers. Self-hosted, you build as many apps as your server can handle.

Custom integrations: Open-source platforms let you modify the source code, write custom plugins, and integrate with proprietary systems that SaaS platforms would never support.

Long-term stability: Open-source projects can’t be acquired and shut down. Your self-hosted instance runs independently of any company’s business decisions.

At a Glance: Budibase vs Appsmith vs ToolJet

Appsmith: The Data-First Admin Panel Builder

Appsmith is the most popular open-source low-code platform by GitHub stars. Its strength lies in connecting to virtually any data source — 25+ database types and API protocols — and rapidly building admin panels, CRUD interfaces, and dashboards on top of them.

Appsmith runs as a single Docker container, making it the easiest to deploy. You connect it to your existing databases, drag UI widgets onto a canvas, bind queries to those widgets, and deploy. The entire workflow is designed around the “connect, build, deploy” paradigm.

Key Features

• 25+ data source connectors: PostgreSQL, MySQL, MongoDB, Redis, Elasticsearch, Snowflake, Oracle, Google Sheets, and any REST or GraphQL API
• Widget library: Tables, forms, charts, maps, modals, tabs, file pickers, rich text editors, and more
• JavaScript everywhere: Write JS in query responses, widget properties, and event handlers for full customization
• Version control: Built-in Git integration — every app is a Git repository you can version, branch, and review
• Role-based access control: Define user groups and restrict app or page access
• Embeddable: Embed Appsmith apps into existing web applications via iframe

Docker Compose for Appsmith

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

version: "3"

services:
  appsmith:
    image: index.docker.io/appsmith/appsmith-ce:release
    container_name: appsmith
    ports:
      - "8080:80"
    environment:
      APPSMITH_ENCRYPTION_PASSWORD: your-secure-password
      APPSMITH_ENCRYPTION_SALT: your-secure-salt
    volumes:
      - ./appsmith-stacks:/appsmith-stacks
    restart: unless-stopped

Deploy with:

1
2

mkdir -p appsmith-stacks
docker compose up -d

The instance will be available at http://localhost:8080. All persistent data lives in the appsmith-stacks directory, which you should back up regularly.

Budibase: The Full-Stack Internal App Platform

Budibase takes a different approach. Rather than just connecting to external data, it provides a built-in database (CouchDB under the hood), an automation engine, and a visual UI builder — making it a complete end-to-end platform. You can build an app from scratch without any external data sources at all.

Budibase’s architecture is multi-service: it runs separate containers for the app service, worker service, CouchDB, MinIO (object storage), Redis, and a proxy. This makes it more complex to deploy but gives you a fully self-contained internal app ecosystem.

Key Features

• Built-in database: Create and manage data tables directly within Budibase — no external database required
• External data sources: PostgreSQL, MySQL, MongoDB, REST APIs, S3, CouchDB, and more
• Automation engine: Trigger workflows on data changes, schedule recurring tasks, send emails, call webhooks, and update records
• Portals: Group multiple apps into a single navigable portal for your team
• Mobile-responsive: Automatically generates mobile-optimized views of your apps
• Pre-built templates: CRM, inventory tracker, project management, helpdesk, and more
• Custom plugins: Extend the platform with custom data providers and UI components

Docker Compose for Budibase

Budibase requires multiple services. Create a .env file first:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

MAIN_PORT=10000
COUCH_DB_USER=budibase
COUCH_DB_PASSWORD=secure-couch-password
MINIO_ACCESS_KEY=budibase-minio-key
MINIO_SECRET_KEY=secure-minio-secret-key
INTERNAL_API_KEY=secure-internal-api-key
API_ENCRYPTION_KEY=secure-encryption-key
JWT_SECRET=secure-jwt-secret
REDIS_PASSWORD=secure-redis-password
BUDIBASE_ENVIRONMENT=PRODUCTION
BB_ADMIN_USER_EMAIL=admin@example.com
BB_ADMIN_USER_PASSWORD=admin-secure-password
PLUGINS_DIR=
OFFLINE_MODE=

Then create docker-compose.yaml:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

version: "3"

services:
  app-service:
    restart: unless-stopped
    image: budibase/apps
    container_name: bbapps
    environment:
      SELF_HOSTED: 1
      COUCH_DB_URL: http://${COUCH_DB_USER}:${COUCH_DB_PASSWORD}@couchdb-service:5984
      WORKER_URL: http://worker-service:4003
      MINIO_URL: http://minio-service:9000
      MINIO_ACCESS_KEY: ${MINIO_ACCESS_KEY}
      MINIO_SECRET_KEY: ${MINIO_SECRET_KEY}
      INTERNAL_API_KEY: ${INTERNAL_API_KEY}
      JWT_SECRET: ${JWT_SECRET}
      PORT: 4002
      API_ENCRYPTION_KEY: ${API_ENCRYPTION_KEY}
      REDIS_URL: redis-service:6379
      REDIS_PASSWORD: ${REDIS_PASSWORD}
    depends_on:
      - worker-service
      - redis-service

  worker-service:
    restart: unless-stopped
    image: budibase/worker
    container_name: bbworker
    environment:
      SELF_HOSTED: 1
      PORT: 4003
      CLUSTER_PORT: ${MAIN_PORT}
      API_ENCRYPTION_KEY: ${API_ENCRYPTION_KEY}
      JWT_SECRET: ${JWT_SECRET}
      REDIS_URL: redis-service:6379
      REDIS_PASSWORD: ${REDIS_PASSWORD}
      COUCH_DB_URL: http://${COUCH_DB_USER}:${COUCH_DB_PASSWORD}@couchdb-service:5984
    depends_on:
      - redis-service

  couchdb-service:
    restart: unless-stopped
    image: budibase/couchdb
    container_name: bbcouch
    environment:
      COUCHDB_USER: ${COUCH_DB_USER}
      COUCHDB_PASSWORD: ${COUCH_DB_PASSWORD}
    volumes:
      - couchdb_data:/opt/couchdb/data

  minio-service:
    restart: unless-stopped
    image: minio/minio
    container_name: bbminio
    command: server /data
    environment:
      MINIO_ACCESS_KEY: ${MINIO_ACCESS_KEY}
      MINIO_SECRET_KEY: ${MINIO_SECRET_KEY}
    volumes:
      - minio_data:/data

  redis-service:
    restart: unless-stopped
    image: redis
    container_name: bbredis
    command: redis-server --requirepass ${REDIS_PASSWORD}

  proxy-service:
    restart: unless-stopped
    image: budibase/proxy
    container_name: bbproxy
    ports:
      - "${MAIN_PORT}:10000"
    environment:
      MAIN_PORT: ${MAIN_PORT}
      APPS_URL: http://app-service:4002
      WORKER_URL: http://worker-service:4003
    depends_on:
      - app-service
      - worker-service

volumes:
  couchdb_data:
  minio_data:

Deploy with:

1

docker compose up -d

Access Budibase at http://localhost:10000. Log in with the credentials from your .env file.

ToolJet: The Extensible Data Connector Platform

ToolJet sits between Appsmith and Budibase in philosophy. Like Appsmith, it focuses on connecting to external data sources rather than providing a built-in database. But ToolJet supports an even wider range of connectors and offers a plugin architecture that lets the community add new data sources without waiting for official releases.

ToolJet’s architecture uses Docker Compose with separate client, server, and plugins services — plus a PostgreSQL database for storing app definitions and user accounts.

Key Features

• Broad data source support: PostgreSQL, MySQL, MongoDB, Redis, Elasticsearch, Google Sheets, Stripe, Slack, Twilio, Salesforce, and 50+ more
• Plugin marketplace: Community-contributed connectors that extend beyond the core platform
• Query builder: Visual query builder for databases with a JavaScript mode for complex queries
• Multi-environment support: Manage development, staging, and production environments
• Version control: Git sync for app definitions
• Row-level security: Restrict data access at the row level based on user attributes
• Custom JavaScript components: Build and deploy custom UI components

Docker Compose for ToolJet

ToolJet requires PostgreSQL for its internal state. Here’s a production-ready compose file:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

version: "3"

services:
  tooljet-db:
    image: postgres:14
    container_name: tooljet-db
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: secure-db-password
      POSTGRES_DB: tooljet
    volumes:
      - tj-db-data:/var/lib/postgresql/data
    restart: unless-stopped

  tooljet:
    image: tooljet/tooljet-ce:latest
    container_name: tooljet
    ports:
      - "8082:80"
    environment:
      LOCKBOX_MASTER_KEY: "your-master-key-at-least-32-chars"
      SECRET_KEY_BASE: "your-secret-key-base-at-least-64-characters-long"
      SERVICE_ORM: "true"
      PG_HOST: tooljet-db
      PG_USER: postgres
      PG_PASS: secure-db-password
      PG_DB: tooljet
      PG_PORT: 5432
      ENCRYPTION_KEY: "your-encryption-key-32chars!"
      DEPLOYMENT_ENV: production
      NODE_ENV: production
      TOOLJET_HOST: "http://localhost:8082"
      SECRET_STORAGE_STRATEGY: ENV
      CLIENT_ID: ""
      CLIENT_SECRET: ""
    depends_on:
      - tooljet-db
    restart: unless-stopped

volumes:
  tj-db-data:

Deploy with:

1

docker compose up -d

ToolJet will be available at http://localhost:8082. Create your admin account on first launch.

Choosing the Right Platform

Choose Appsmith if: You need the simplest deployment (single Docker container) and your primary use case is building admin panels and dashboards on top of existing databases. It has the largest community, the most third-party tutorials, and the broadest database support out of the box.

Choose Budibase if: You want a complete internal app ecosystem — built-in database, automation engine, and mobile-responsive apps — all in one platform. It’s ideal for teams that want to build apps from scratch without setting up a separate database first.

Choose ToolJet if: You need the widest range of data connectors and want a plugin architecture that lets the community extend the platform. Its row-level security and multi-environment support make it a strong choice for larger teams with complex access control requirements.

FAQ

Can I use these platforms for free in production?

Yes. All three platforms — Appsmith, Budibase, and ToolJet — offer fully functional self-hosted community editions that are free to use in production. Appsmith uses the Apache-2.0 license, ToolJet uses AGPL-3.0, and Budibase uses GPL-3.0 for its community edition. No license fees or user limits apply when self-hosting.

Which platform is easiest to deploy?

Appsmith is the simplest, requiring only a single Docker container. ToolJet needs two containers (app + PostgreSQL). Budibase is the most complex with 6+ services (apps, worker, CouchDB, MinIO, Redis, proxy). For quick evaluation, Appsmith gets you running in under a minute.

Can I migrate data between platforms?

There is no direct migration tool between these platforms. Each uses its own app definition format and data storage approach. However, since all three connect to the same external databases (PostgreSQL, MySQL, MongoDB, etc.), your underlying data remains portable. You would need to rebuild the UI and queries on the target platform.

Do these platforms support authentication and user management?

Yes. All three provide built-in authentication with options for email/password, Google OAuth, OIDC, and SAML (enterprise). Budibase additionally offers built-in user management with role-based access. Appsmith and ToolJet integrate with external identity providers for advanced user management.

How do I back up my self-hosted instance?

For Appsmith, back up the appsmith-stacks volume directory. For Budibase, back up the CouchDB and MinIO volumes (couchdb_data, minio_data). For ToolJet, back up the PostgreSQL database (pg_dump) and any persistent volumes. Always test your backups by restoring to a separate instance before relying on them.

Can I run these behind a reverse proxy with HTTPS?

Yes. All three platforms are standard web applications that work behind nginx, Caddy, Traefik, or any reverse proxy. Simply route traffic from your domain to the platform’s local port and configure SSL termination at the proxy layer.

For related reading, see our Appsmith automation alternative comparison for workflow-based internal tools, the n8n vs Node-RED vs ActivePieces guide for automation-first workflows, and the Superset vs Metabase vs Lightdash BI dashboard comparison for data visualization on top of the databases these platforms connect to.