DEV Community

Royce
Royce

Posted on • Originally published at ossalt.com

Self-Host Appsmith: Open Source Retool Alternative 2026

#appsmith #internaltools #selfhosting #docker

How to Self-Host Appsmith: Open Source Retool Alternative in 2026

TL;DR

Retool charges $65/user/month with no free self-hosted option. Appsmith is the open source alternative — 39,400+ GitHub stars, Apache 2.0 license, and a Community Edition you can self-host for free with unlimited users. It connects to 25+ databases and any REST or GraphQL API. The Business tier ($15/user/month) adds RBAC, SSO, and audit logs. If you're building internal dashboards, admin panels, or CRUD tools and don't want per-seat SaaS fees eating your runway, this guide walks you through a production-ready Appsmith deployment in under 30 minutes.

Key Takeaways

  • Open source, truly free to self-host: Community Edition is Apache 2.0 — unlimited users, no license fees, data stays on your servers
  • 39,400+ GitHub stars: One of the most-starred internal tools platforms ever built
  • 25+ native integrations: PostgreSQL, MySQL, MongoDB, Redis, Elasticsearch, REST APIs, GraphQL, S3, and more
  • Drag-and-drop builder: 45+ UI components including tables, forms, charts, modals, and custom widgets
  • Git sync built-in: Connect your Appsmith apps to a GitHub/GitLab repo — treat your internal tools as code
  • Business plan: $15/user/month unlocks RBAC, SSO (Google, GitHub, OIDC, SAML), and audit logs
  • Retool comparison: Appsmith is ~75% cheaper per user and fully self-hostable; Retool's mobile app builder and server-side Python are still exclusive

Why Teams Switch from Retool to Appsmith

Retool is excellent. It's also expensive and closed-source — and that combination is causing a wave of migrations.

Retool charges $65/user/month on the Business plan. For a 20-person team that regularly builds or maintains internal tools, that's $1,300/month — $15,600/year — with no way to audit the code, no ability to self-host for free, and your data touching Retool's infrastructure by default.

Appsmith flips the model. The Community Edition is open source under Apache 2.0: free to self-host, unlimited users, no expiry. You pay for a VPS (typically $10-25/month on Hetzner or DigitalOcean) rather than per seat.

The trade-offs are real. Retool has a native mobile app builder and server-side Python execution. Appsmith runs JavaScript client-side, which can struggle with very large dataset transformations. Retool also has 70+ native SaaS connectors vs. Appsmith's 25+. But for the core use case — PostgreSQL-backed admin panels, CRUD apps, and dashboards — Appsmith is functionally equivalent at a fraction of the cost.

Feature Appsmith Retool
Open source ✅ Apache 2.0 ❌ Proprietary
Free self-hosted ✅ Unlimited users ❌ Requires paid license
Business plan pricing $15/user/month $65/user/month
GitHub stars 39,400+ N/A (closed source)
Native integrations 25+ 70+
Mobile app builder ❌ ✅
Server-side JS/Python Client-side only ✅ Server-side
Embedded apps ✅ ❌
Git version control ✅ ✅ (paid plans)
G2 rating 4.7/5 4.5/5

System Requirements

Before deploying, confirm your server meets these minimums:

  • CPU: 2 vCPU minimum (4 vCPU recommended for teams)
  • RAM: 4GB minimum (8GB recommended)
  • Storage: 20GB SSD minimum
  • OS: Ubuntu 20.04+, Debian 11+, or any Docker-compatible Linux
  • Docker: v20.10.7+
  • Docker Compose: v2.x (the docker compose v2 plugin, not legacy docker-compose)
  • Ports: 80 and 443 open on your firewall
  • Domain: A subdomain pointing to your server IP (for production TLS)

Recommended server (2026 pricing):

  • Hetzner CX22: 2 vCPU, 4GB RAM, €4.35/month — handles 1-25 users
  • Hetzner CX32: 4 vCPU, 8GB RAM, €8.70/month — handles 25-100 users

Self-Hosting with Docker Compose

Appsmith ships as a single Docker image that bundles the application, MongoDB, and Redis internally. It's intentionally simple to operate — one container, one volume.

Step 1: Create the Directory 

mkdir -p ~/appsmith && cd ~/appsmith
Enter fullscreen mode Exit fullscreen mode

Step 2: Create docker-compose.yml

Appsmith offers two editions: Community (CE) which is open source and Enterprise Edition (EE) which is the commercial build with a free tier. Use EE if you want the free tier that allows future upgrade — or CE for pure open source.

# docker-compose.yml
version: "3"

services:
  appsmith:
    image: index.docker.io/appsmith/appsmith-ee  # Use appsmith-ce for pure OSS
    container_name: appsmith
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./stacks:/appsmith-stacks
    restart: unless-stopped
    # Appsmith bundles MongoDB and Redis internally.
    # No additional services needed for single-node deployments.
Enter fullscreen mode Exit fullscreen mode

For the Community Edition (pure Apache 2.0, no enterprise feature upgrade path):

version: "3"

services:
  appsmith:
    image: index.docker.io/appsmith/appsmith-ce
    container_name: appsmith
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./stacks:/appsmith-stacks
    restart: unless-stopped
Enter fullscreen mode Exit fullscreen mode

Step 3: Launch 

docker compose up -d

# Watch startup logs (takes 3-5 minutes on first boot)
docker compose logs -f appsmith
Enter fullscreen mode Exit fullscreen mode

Look for this line to confirm readiness:

appsmith | INFO: Server is ready at localhost:8080
Enter fullscreen mode Exit fullscreen mode

Then open http://your-server-ip in your browser.

Step 4: First-Run Setup

On first access, Appsmith runs the setup wizard:

  1. Create admin account — email + password (this is your superadmin)
  2. Instance name — displayed in the header (e.g., "Acme Internal Tools")
  3. Configure email (optional but recommended for invitations and alerts)

Connecting Your First Database

PostgreSQL 

Settings → Datasources → + New Datasource → PostgreSQL

Connection Settings:
  Host: your-postgres-host.internal  (or public IP)
  Port: 5432
  Database: your_database
  Username: app_readonly            (create a read-only user for safety)
  Password: ***

SSL: Required for remote DBs / Optional for internal
Enter fullscreen mode Exit fullscreen mode

Click Test to verify connectivity, then Save. Appsmith immediately makes all tables available for query.

Create your first query:

-- In the query editor
SELECT
  id,
  email,
  name,
  created_at,
  status
FROM users
WHERE status = {{statusFilter.selectedOptionValue}}
ORDER BY created_at DESC
LIMIT 100
Enter fullscreen mode Exit fullscreen mode

The {{statusFilter.selectedOptionValue}} syntax binds directly to a Select widget on your page — no manual wiring needed.

MySQL 

+ New Datasource → MySQL

Host: mysql.internal
Port: 3306
Database: production_db
Username: appsmith_ro
Password: ***
Enter fullscreen mode Exit fullscreen mode

REST API (External Services) 

+ New Datasource → REST API

Base URL: https://api.stripe.com/v1
Headers:
  Authorization: Bearer {{appsmith.store.STRIPE_SECRET}}

Create queries:
  GET /customers                    → List customers
  GET /customers/{{customerId}}     → Single customer
  POST /customers                   → Create customer
  POST /refunds                     → Issue refund
Enter fullscreen mode Exit fullscreen mode

Use appsmith.store to reference secrets stored in Appsmith's environment variable vault — they're never exposed to browser clients.

Supported Integrations

Appsmith natively connects to:

Category Databases & Services
SQL PostgreSQL, MySQL, MSSQL, SQLite, Oracle, MariaDB
NoSQL MongoDB, Redis, Elasticsearch, Firestore, DynamoDB
REST/GraphQL Any REST API, GraphQL
Cloud AWS S3, Google Sheets, Airtable, HubSpot, Salesforce
Message queues SMTP, Twilio

For services not on the list, the REST API datasource handles anything with HTTP endpoints.

Building Your First App: Admin Dashboard in 10 Minutes

Scaffold from a Template

Appsmith ships with 200+ templates. For an admin panel:

New App → Templates → Admin Panel with PostgreSQL
→ Select your PostgreSQL datasource
→ Generate
Enter fullscreen mode Exit fullscreen mode

Appsmith auto-creates a CRUD interface for each table: list view with search/filter, edit form, delete confirmation, and pagination.

Manual Build: Users Table

Step 1 — Add a Table widget
Drag a Table widget onto the canvas. In the widget's properties:

// Table Data
{{getUsersQuery.data}}
Enter fullscreen mode Exit fullscreen mode

Step 2 — Create the query

SELECT id, email, name, status, created_at
FROM users
ORDER BY created_at DESC
LIMIT {{pageSize.text || 50}}
OFFSET {{(usersTable.pageNo - 1) * (pageSize.text || 50)}}
Enter fullscreen mode Exit fullscreen mode

Step 3 — Add an action button
Drag a Button widget into the table's action column. In onClick:

{{suspendUserMutation.run(
  () => showAlert("User suspended", "success"),
  () => showAlert("Failed: " + suspendUserMutation.error, "error")
)}}
Enter fullscreen mode Exit fullscreen mode

The entire flow — table, pagination, action buttons, confirmation modal — takes about 5-10 minutes with no backend code.

Git Sync: Treat Internal Tools as Code

Appsmith's Git integration is one of its biggest production advantages over competitors. Connect your Appsmith app to a Git repo:

App Settings → Git Connection → Connect Git

1. Generate a deploy key (Appsmith creates an SSH key pair)
2. Add the public key to your GitHub/GitLab repo as a deploy key
3. Paste the repo SSH URL: git@github.com:yourorg/internal-tools.git
4. Click Connect
Enter fullscreen mode Exit fullscreen mode

From this point:

  • Commit changes directly from the Appsmith editor
  • Branch support: create feature branches, review changes in PR, merge to main
  • Multiple environments: connect your main branch to production, staging branch to staging
  • Team collaboration: multiple developers can work on different branches simultaneously

This is a meaningful differentiator. Most low-code tools treat apps as opaque blobs in a database. Appsmith apps as Git repos means full change history, code review workflows, and the ability to roll back any change.

Role-Based Access Control

On the Community Edition, access control is app-level: you can invite users and set them as viewer or editor.

On the Business Edition ($15/user/month), you get granular RBAC:

Admin Console → Access Control

Workspace Roles:
  Administrator    → Full access (create, edit, delete, invite)
  Developer        → Create and edit apps
  Viewer           → Read-only access

Per-App Permissions:
  Each app can override workspace defaults
  Example: Finance app → restrict to Finance group only
Enter fullscreen mode Exit fullscreen mode

Set up groups:

Admin Console → Groups → + Create Group

Group: "Finance Team"
Members: alice@company.com, bob@company.com
Apps: Grant "Finance Dashboard" → Viewer
      Grant "Finance Admin" → Editor
Enter fullscreen mode Exit fullscreen mode

The Business tier also adds SSO — connect to Google Workspace, GitHub, Okta, Azure AD, or any OIDC/SAML provider. Users log in with their existing company credentials; no separate account needed.

Custom Domain and TLS

Appsmith handles TLS termination internally using Certbot/Let's Encrypt.

Point Your DNS 

# In your DNS provider, add an A record:
subdomain.yourdomain.com → your.server.ip.address
Enter fullscreen mode Exit fullscreen mode

Configure the Domain 

docker exec -it appsmith /bin/bash

# Inside the container
appsmithctl configure
→ Enter your domain: tools.yourcompany.com
→ Appsmith fetches a Let's Encrypt certificate automatically
Enter fullscreen mode Exit fullscreen mode

Or configure via environment variable before first launch:

# docker-compose.yml
services:
  appsmith:
    image: appsmith/appsmith-ee
    environment:
      - APPSMITH_CUSTOM_DOMAIN=tools.yourcompany.com
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./stacks:/appsmith-stacks
Enter fullscreen mode Exit fullscreen mode

After DNS propagates (1-5 minutes), Appsmith is accessible at https://tools.yourcompany.com with a valid SSL certificate. Auto-renews every 90 days.

Appsmith Agents: AI in Internal Tools

In 2026, Appsmith introduced Agents — AI-powered assistants embedded directly in your internal tools. Instead of building forms for every workflow, agents can:

  • Accept natural language queries: "Show me all users who signed up in the last 7 days and haven't verified their email"
  • Execute multi-step workflows: query DB → transform data → call API → send notification
  • Generate reports on demand without pre-built queries

Configure an agent:

New App → AI Agent
→ Connect datasources (PostgreSQL, REST APIs)
→ Define permissions (which tables/endpoints the agent can access)
→ Set context: "This agent helps our support team look up customer orders"
Enter fullscreen mode Exit fullscreen mode

Agents use your connected datasources under the hood — they don't send your data to external AI providers unless you explicitly configure an external LLM. The agent can run against a local Ollama instance for fully air-gapped deployments.

Production Hardening

Backups

Appsmith stores all data in the ./stacks volume. Back it up with a cron job:

#!/bin/bash
# backup-appsmith.sh
DATE=$(date +%Y%m%d_%H%M)
BACKUP_DIR="/backups/appsmith"

mkdir -p $BACKUP_DIR

# Stop app briefly for consistent backup (or use --no-stop for hot backup)
# docker compose stop appsmith

# Backup the entire stacks volume
tar -czf "$BACKUP_DIR/appsmith_$DATE.tar.gz" ~/appsmith/stacks/

# Resume
# docker compose start appsmith

# Upload to S3 or remote storage
rclone copy "$BACKUP_DIR/appsmith_$DATE.tar.gz" s3remote:backups/appsmith/

# Retain only last 30 days
find $BACKUP_DIR -name "appsmith_*.tar.gz" -mtime +30 -delete

echo "Appsmith backup complete: appsmith_$DATE.tar.gz"
Enter fullscreen mode Exit fullscreen mode

Add to cron: 0 2 * * * /opt/scripts/backup-appsmith.sh

Updates 

cd ~/appsmith

# Pull latest image
docker compose pull

# Restart with new image
docker compose up -d

# Appsmith runs database migrations automatically on startup
# Watch logs to confirm clean migration
docker compose logs -f appsmith | grep -E "migration|error|ready"
Enter fullscreen mode Exit fullscreen mode

Check the Appsmith releases page before major version upgrades — occasionally breaking changes require manual steps.

Environment Variables for Hardening 

# docker-compose.yml — production additions
environment:
  - APPSMITH_DISABLE_TELEMETRY=true         # Disable usage data collection
  - APPSMITH_SIGNUP_DISABLED=false          # Set to true after team onboarding
  - APPSMITH_ADMIN_EMAILS=admin@company.com # Only these emails can create admin accounts
  - APPSMITH_RATE_LIMIT=RPS:50             # Rate limit API calls
Enter fullscreen mode Exit fullscreen mode

Scaling Beyond Single Node

The default single-container deployment handles 100+ concurrent users comfortably on a 4 vCPU / 8GB RAM server. For higher availability:

Option 1: Kubernetes (documented by Appsmith)

# Appsmith publishes Helm charts
helm repo add appsmith https://helm.appsmith.com
helm install appsmith appsmith/appsmith \
  --set persistence.storageClass=standard \
  --set replicaCount=2
Enter fullscreen mode Exit fullscreen mode

Option 2: External MongoDB + Redis (for stateless app containers)

environment:
  - APPSMITH_MONGODB_URI=mongodb://mongo.internal:27017/appsmith
  - APPSMITH_REDIS_URL=redis://redis.internal:6379
Enter fullscreen mode Exit fullscreen mode

With external databases, you can run multiple appsmith containers behind a load balancer. Each container is stateless — sessions are stored in Redis, data in MongoDB.

Typical capacity (single node):
| Team size | vCPU | RAM | Monthly cost (Hetzner) |
|-----------|------|-----|------------------------|
| 1-25 users | 2 | 4GB | ~€6 (~$6.50) |
| 25-75 users | 4 | 8GB | ~€12 (~$13) |
| 75-200 users | 8 | 16GB | ~€25 (~$27) |

Cost Comparison: Retool vs Appsmith Self-Hosted

Scenario Retool (Business) Appsmith CE (Self-hosted) Appsmith Business
5 users $325/month ~$7/month (VPS) $75/month + VPS
20 users $1,300/month ~$13/month (VPS) $300/month + VPS
50 users $3,250/month ~$25/month (VPS) $750/month + VPS
100 users $6,500/month ~$25/month (VPS) $1,500/month + VPS
SSO/SAML Included ❌ CE ✅ Business
Audit logs Included ❌ CE ✅ Business
Data location Retool's cloud Your servers Your servers

For a 20-person engineering team, the switch from Retool to self-hosted Appsmith Community saves $1,287/month — $15,444/year. Even on the Business tier with SSO, you save $1,000/month versus Retool while keeping data on-premises.

Appsmith vs Budibase vs ToolJet: Which Internal Tool Platform?

Appsmith Budibase ToolJet
GitHub stars 39,400+ 22,000+ 33,000+
License Apache 2.0 GPL v3 AGPL v3
Built-in database ❌ (external only) ✅ CouchDB-based ✅ PostgreSQL
Automation/workflows Limited ✅ Built-in ✅ Built-in
Git sync ✅ Native ❌ ❌
Custom widgets ✅ React-based ✅ Svelte ✅ React
Best for Complex data apps + Git workflows Full-stack internal apps Automation-heavy tools

Choose Appsmith when Git integration matters — if your team already uses GitOps and wants to review app changes in PRs, Appsmith is the only open source option with native Git sync. Choose Budibase for automation workflows without needing external services. Choose ToolJet if you want a built-in database without the overhead of CouchDB.

Methodology

Find more open source Retool alternatives on OSSAlt — self-hosting guides, community ratings, and feature comparisons.

Related: How to Self-Host Budibase: Open Source Retool Alternative 2026 · How to Migrate from Retool to Appsmith 2026 · Best Open Source Alternatives to Retool 2026

Top comments (0)