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

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.

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

Step 3: Launch

docker compose up -d

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

Look for this line to confirm readiness:

appsmith | INFO: Server is ready at localhost:8080

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

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

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: ***

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

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

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}}

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)}}

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")
)}}

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

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

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

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

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

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

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"

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"

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"

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

---

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

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

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

• GitHub stats from github.com/appsmithorg/appsmith, March 2026
• Pricing from appsmith.com/pricing, March 2026
• Installation guide based on Appsmith Docker documentation
• Retool pricing from retool.com/pricing, March 2026
• Sources: Retool vs Appsmith comparison, Superblocks Appsmith pricing guide, Appsmith official blog
• Version: Appsmith EE/CE (check GitHub releases for current tag)

---

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