Appsmith vs ToolJet: Which Low-Code Platform to Self-Host?

Building internal tools from scratch wastes engineering time. Admin dashboards, CRUD interfaces, approval workflows, customer support panels — these are necessary but repetitive. Both Appsmith and ToolJet let you drag-and-drop these tools together, wire them to your existing databases and APIs, and deploy them without spinning up a full frontend project. They are the two leading open-source alternatives to Retool, and both can be self-hosted.

The question is which one fits your stack and your team better.

Quick Verdict

Appsmith is the stronger choice for most teams. It has a more mature visual builder, better Git sync for version-controlled workflows, superior documentation, and a larger community. ToolJet catches up on built-in data source count and ships a native no-code database, but its builder feels rougher and its self-hosted setup carries more moving parts. If your priority is a polished, reliable internal tool platform that your team can adopt quickly, start with Appsmith.

Choose ToolJet if you need its built-in database for quick prototyping or if your stack is already PostgreSQL-heavy and you prefer AGPL licensing over Apache 2.0.

Feature Comparison

Feature	Appsmith	ToolJet
Visual builder	Drag-and-drop canvas with grid layout	Drag-and-drop canvas with grid layout
Built-in widgets/components	45+ widgets	60+ components
Data source integrations	25+ (databases, REST, GraphQL, SaaS)	80+ (databases, REST, GraphQL, SaaS, cloud storage)
JavaScript support	Full JS in queries, widgets, and transformations	Full JS in queries and components
Python support	No	Yes (run Python in-browser)
Built-in database	No (connects to external DBs)	Yes (ToolJet Database, Postgres-backed)
Git sync	Full Git integration with branching and merge	Git sync available (less mature)
RBAC	Granular role-based access control	Role-based access with groups
Audit logs	Available in Business/Enterprise edition	Available in CE (v3.20+)
App embedding	iframe embedding supported	iframe embedding supported
Multi-page apps	Yes	Yes, with multiplayer editing
Mobile responsive	Responsive layouts, no native mobile	Responsive layouts, no native mobile
REST API	Yes	Yes
Workflow/automation	Limited (JS-based logic)	Built-in workflows with visual builder
Self-hosting ease	Single container (all-in-one)	Multiple containers (app + Postgres + PostgREST)
Resource usage	~1.5-2 GB RAM (includes embedded MongoDB + Redis)	~1 GB RAM (app) + Postgres overhead
License	Apache 2.0 (CE)	AGPL 3.0 (CE)
GitHub stars	39.2k	37.5k
Backing	YC-backed, venture funded	YC-backed, venture funded

Overview

Appsmith

Appsmith is an open-source low-code platform for building internal tools. It launched in 2019 and has become the most popular open-source Retool alternative. The platform is built with Java on the backend and TypeScript/React on the frontend. Appsmith’s Community Edition bundles everything into a single Docker container — the application server, an embedded MongoDB instance, and Redis — which makes deployment straightforward at the cost of a larger memory footprint.

Appsmith’s core strength is its visual builder maturity. The query editor supports SQL, REST, GraphQL, and JavaScript transformations natively. Git sync lets teams version-control their apps alongside code, with proper branching and merge support. The widget library covers tables, forms, charts, modals, lists, tabs, and more — each with deep configuration options.

ToolJet

ToolJet is an open-source low-code platform that takes a slightly different approach. Built with Node.js and React, it separates concerns more cleanly in its architecture: the application runs as one container with PostgreSQL as an external dependency. ToolJet ships a larger number of pre-built data source connectors (80+) and includes a built-in no-code database called ToolJet Database, which is essentially a managed PostgreSQL schema accessible through a spreadsheet-like UI.

ToolJet also supports Python execution alongside JavaScript, which appeals to data-heavy teams. Its workflow builder lets you create multi-step automations triggered by schedules or events — something Appsmith does not offer natively.

Installation Complexity

Appsmith Docker Setup

Appsmith packages everything into a single container. MongoDB and Redis run inside the container, so you do not need to manage them separately. This is the simplest possible deployment for a platform of this complexity.

Create a docker-compose.yml:

services:
  appsmith:
    image: index.docker.io/appsmith/appsmith-ce:v1.96
    container_name: appsmith
    ports:
      - "8080:80"
      - "8443:443"
    volumes:
      - appsmith_data:/appsmith-stacks
    environment:
      # REQUIRED: Change these to random, strong values
      APPSMITH_ENCRYPTION_PASSWORD: "change-me-to-a-strong-random-string"
      APPSMITH_ENCRYPTION_SALT: "change-me-to-another-random-string"
      # Optional: Disable telemetry
      APPSMITH_DISABLE_TELEMETRY: "true"
      # Optional: Configure email for invitations and password reset
      # APPSMITH_MAIL_ENABLED: "true"
      # APPSMITH_MAIL_HOST: "smtp.example.com"
      # APPSMITH_MAIL_PORT: "587"
      # APPSMITH_MAIL_USERNAME: "[email protected]"
      # APPSMITH_MAIL_PASSWORD: "your-smtp-password"
      # APPSMITH_MAIL_FROM: "[email protected]"
    restart: unless-stopped

volumes:
  appsmith_data:

Start it:

docker compose up -d

Appsmith takes 2-5 minutes to initialize on first boot (it sets up the embedded MongoDB and Redis). Access the web UI at http://your-server:8080 and create your admin account.

Key notes:

• APPSMITH_ENCRYPTION_PASSWORD and APPSMITH_ENCRYPTION_SALT encrypt stored data source credentials. Generate strong random values and back them up — losing these means losing access to all saved credentials.
• The /appsmith-stacks volume stores MongoDB data, Redis data, Git repos, logs, and SSL certificates. Back this up regularly.
• Ports 80 and 443 inside the container serve HTTP and HTTPS respectively. Map them to whatever host ports you prefer.

ToolJet Docker Setup

ToolJet requires PostgreSQL as an external service. The official deployment also includes PostgREST for the built-in ToolJet Database feature.

Create a .env file:

# ToolJet configuration
TOOLJET_HOST=http://your-server-ip:8080
LOCKBOX_MASTER_KEY=replace-with-32-char-hex-string-abcdef0123456789
SECRET_KEY_BASE=replace-with-64-char-hex-string-abcdef0123456789abcdef0123456789abcdef0123456789abcdef01234567

# PostgreSQL connection
PG_HOST=postgres
PG_PORT=5432
PG_USER=tooljet
PG_PASS=change-me-strong-database-password
PG_DB=tooljet

# PostgREST (for ToolJet Database feature)
PGRST_HOST=postgrest
PGRST_JWT_SECRET=replace-with-a-random-32-char-string-for-jwt

# Optional: Disable telemetry
DISABLE_TOOLJET_TELEMETRY=true

# Optional: Enable workflow worker
# WORKER=true
# TOOLJET_WORKFLOW_CONCURRENCY=5

Create a docker-compose.yml:

services:
  tooljet:
    image: tooljet/tooljet-ce:v3.20.102-lts
    container_name: tooljet
    ports:
      - "8080:80"
    env_file:
      - .env
    depends_on:
      postgres:
        condition: service_healthy
    restart: unless-stopped

  postgres:
    image: postgres:16.8-alpine
    container_name: tooljet-postgres
    environment:
      POSTGRES_USER: tooljet
      POSTGRES_PASSWORD: change-me-strong-database-password
      POSTGRES_DB: tooljet
    volumes:
      - tooljet_pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U tooljet -d tooljet"]
      interval: 10s
      timeout: 5s
      retries: 5
    restart: unless-stopped

  postgrest:
    image: postgrest/postgrest:v12.0.2
    container_name: tooljet-postgrest
    environment:
      PGRST_SERVER_PORT: "80"
      PGRST_DB_URI: "postgres://tooljet:change-me-strong-database-password@postgres:5432/tooljet"
      PGRST_JWT_SECRET: "replace-with-a-random-32-char-string-for-jwt"
      PGRST_LOG_LEVEL: "error"
    depends_on:
      postgres:
        condition: service_healthy
    restart: unless-stopped

volumes:
  tooljet_pgdata:

Start it:

docker compose up -d

Access the web UI at http://your-server-ip:8080 and create your admin account.

Key notes:

• LOCKBOX_MASTER_KEY encrypts data source credentials. Generate a random 32-character hex string (openssl rand -hex 16). Back this up.
• SECRET_KEY_BASE is used for session signing. Generate a random 64-character hex string (openssl rand -hex 32).
• PGRST_JWT_SECRET authenticates ToolJet’s connection to PostgREST. Use a unique random string.
• The PostgreSQL password must match between the postgres service environment and the .env file (PG_PASS), and also in the PostgREST PGRST_DB_URI.
• If you do not need the ToolJet Database feature, you can remove the postgrest service entirely.

Setup Verdict

Appsmith wins on deployment simplicity. One container, two required environment variables, and you are running. ToolJet requires three containers and careful coordination of shared secrets across services. Neither is difficult, but Appsmith gets you from zero to running in less time with fewer opportunities for misconfiguration.

Data Source Integration

Both platforms connect to the databases and APIs your internal tools need. The approach differs slightly.

Appsmith supports 25+ integrations out of the box: PostgreSQL, MySQL, MongoDB, Microsoft SQL Server, Elasticsearch, DynamoDB, Firestore, Redis, Airtable, Google Sheets, REST API, GraphQL, and more. You configure connections through the UI, write queries in SQL or the native query language, and bind results directly to widgets. Appsmith also supports SMTP for sending emails from within apps.

ToolJet advertises 80+ integrations, which includes everything Appsmith covers plus cloud storage services (S3, GCS, Azure Blob), SaaS tools (Stripe, Twilio, Slack, SendGrid), and its own ToolJet Database. The ToolJet Database is particularly useful for quick prototyping — you can create tables, define columns, and query data without setting up an external database. It is backed by the same PostgreSQL instance ToolJet runs on.

Both handle REST and GraphQL APIs well. Appsmith’s query editor is more polished, with better autocomplete, prepared statement support, and a built-in response viewer. ToolJet’s query builder is functional but less refined.

Winner: ToolJet has more pre-built connectors. Appsmith has a better query editing experience. For most teams, the connectors you actually need (Postgres, MySQL, REST, GraphQL) work well in both. ToolJet’s built-in database is a genuine differentiator for rapid prototyping.

Developer Experience

Appsmith’s builder feels more mature. Widgets snap to a grid with predictable behavior. The property pane gives you fine-grained control over every widget’s appearance, data binding, validation, and event handlers. JavaScript runs everywhere — in query transformations, widget properties, and utility functions through JS Objects. You can write reusable logic once and reference it across your entire app.

Appsmith’s Git sync is a standout feature. You connect a repository, and every change to your app is tracked as a commit. You can create branches, work on features independently, and merge changes back. This makes Appsmith viable for teams that require code review on internal tool changes.

ToolJet’s builder is capable but less polished. The component library is larger (60+ vs 45+), but individual components have fewer configuration options. ToolJet supports both JavaScript and Python execution, which is a meaningful advantage for data teams that think in Python. The multiplayer editing feature lets multiple developers work on the same app simultaneously — Appsmith does not offer this.

ToolJet’s workflow builder lets you create multi-step automations: trigger on a schedule, query a database, transform the data, send a Slack notification. Appsmith has no equivalent — you would need to pair it with n8n or another automation tool.

Winner: Appsmith for builder maturity and Git workflows. ToolJet for Python support and built-in automations. Teams that prioritize development rigor and version control should lean Appsmith. Teams that want rapid prototyping with less ceremony may prefer ToolJet.

Performance and Resource Usage

Appsmith runs heavier because the single container bundles a JVM-based backend, MongoDB, and Redis. Expect 1.5-2 GB of RAM at idle with a handful of apps. Under load with multiple concurrent users, it can climb to 3-4 GB. CPU usage is moderate — the Java backend handles most computation, and the frontend is a standard React SPA. Cold start takes 2-5 minutes as MongoDB and Redis initialize.

ToolJet is lighter on the application side. The Node.js server idles around 500 MB-1 GB. However, you also run PostgreSQL (200-500 MB) and optionally PostgREST (minimal). Total memory usage is comparable to Appsmith at 1-1.5 GB for a light deployment, but ToolJet scales more predictably because each component can be tuned independently. Cold start is faster — typically under a minute.

Winner: ToolJet is slightly more efficient and gives you more control over resource allocation. Appsmith’s all-in-one approach trades resource efficiency for deployment simplicity. On a server with 4 GB of RAM, both run comfortably. Below 2 GB, neither is a good fit.

Use Cases

Choose Appsmith If…

• You need version-controlled internal tools with proper Git branching and merge
• Your team values a polished, predictable visual builder over raw feature count
• You want the simplest possible self-hosted deployment (one container)
• Apache 2.0 licensing matters to your organization (more permissive than AGPL)
• You are building complex multi-page admin panels with many interrelated queries
• Documentation quality and community size matter to you (Appsmith’s docs are better)

Choose ToolJet If…

• You need a built-in database for quick prototyping without external DB setup
• Your team writes Python and wants to use it inside internal tools
• You need built-in workflow automation (scheduled jobs, multi-step pipelines)
• You want multiplayer editing for collaborative app building
• You prefer AGPL licensing (stronger copyleft guarantees)
• You connect to many SaaS tools and want pre-built connectors rather than raw REST calls

Final Verdict

Appsmith is the better platform for most self-hosting teams building internal tools. Its visual builder is more refined, its Git integration enables real development workflows, its single-container deployment reduces operational overhead, and its documentation makes onboarding straightforward. When your engineering team needs to build admin dashboards, customer support tools, or approval workflows against existing databases, Appsmith gets you there with fewer rough edges.

ToolJet is not far behind and wins on specific points: built-in database, Python support, workflow automation, and a larger connector library. If those features align with your stack — particularly if you are a data-heavy team that thinks in Python — ToolJet is worth evaluating. But for the general case of “we need to stop building CRUD interfaces from scratch,” Appsmith is the more mature and reliable choice.

Both are actively developed, well-funded (YC-backed), and have strong communities. You are not making a bad choice either way. But if you are picking one today to standardize on, pick Appsmith.

Related

• Best Self-Hosted Low-Code Platforms
• Self-Hosted Alternatives to Retool
• Docker Compose Basics
• Reverse Proxy Setup
• PocketBase vs Appwrite