How to Migrate from Retool to Appsmith in 2026

Why Teams Move from Retool to Appsmith

Retool's pricing structure creates a scaling problem. The Team plan costs $10/user/month for standard users (builders) and $5/user/month for end users. Business plan is $65/user/month for builders, $18/user/month for end users.

For a 5-developer team building internal tools used by 50 employees:

• Retool Team: 5 × $10 + 50 × $5 = $3,600/year
• Retool Business: 5 × $65 + 50 × $18 = $14,700/year
• Appsmith self-hosted: $78/year (Hetzner server)

The feature gap that justifies Retool's pricing has narrowed significantly in 2025-2026. Appsmith now offers Git integration, real-time collaboration, 45+ native datasource integrations, and a comparable visual builder. Most Retool workflows can be rebuilt in Appsmith.

This guide walks through the complete migration process.

Before You Start: Understand What You're Moving

Retool and Appsmith are both low-code internal tool builders, but they differ in how they structure applications.

Retool concepts:

• Apps (individual internal tool pages)
• Query Library (reusable API queries)
• Workflows (automated multi-step processes)
• Resources (database/API connections)
• Modules (reusable component groups)

Appsmith equivalents:

• Applications → Pages within Applications
• Datasources (equivalent to Resources)
• JS Objects (reusable JavaScript logic)
• Packages (reusable widget groups — Appsmith's module equivalent)
• Workflows (Appsmith Workflows, similar to Retool Workflows)

The migration is a rebuild, not an export-import. Retool and Appsmith don't share a compatible format. Budget time for rebuilding each app.

Step 1: Audit Your Retool Environment

Before moving anything, catalog everything you have.

Export App Inventory

In Retool, go to the main dashboard and list every app. For each app, document:

• App name and purpose
• Datasources it connects to
• Approximate complexity (number of components, queries)
• Who uses it and how frequently
• Any Retool-specific features it relies on (mobile builder, Workflows, Modules)

App Audit Template:
| App Name | Datasources | Complexity | Daily Users | Dependencies |
|----------|-------------|------------|-------------|--------------|
| User Admin | PostgreSQL, REST API | High | 5 devs | Retool Workflows |
| Order Dashboard | PostgreSQL | Medium | 20 ops | None |
| Support Lookup | MySQL, Zendesk API | Low | 10 support | None |

Identify Migration Complexity

Classify each app:

Simple (rebuild in 1-2 hours): Single datasource, basic CRUD operations, simple table/form layout.

Medium (rebuild in 4-8 hours): Multiple datasources, custom JavaScript, several interactive components, basic workflows.

Complex (rebuild in 1-3 days): Heavy JavaScript logic, Retool Modules, Workflows with multiple branches, mobile app versions, custom auth.

Start with simple apps. Build confidence with the Appsmith platform before tackling complex migrations.

Step 2: Self-Host Appsmith

Deploy Appsmith

# Quick install (recommended)
curl -L https://bit.ly/32jBNin | bash

# Or Docker Compose
mkdir appsmith && cd appsmith
curl -L https://bit.ly/3AQzII6 -o docker-compose.yml
docker compose up -d

For production, use Docker Compose with explicit configuration:

services:
  appsmith:
    image: index.docker.io/appsmith/appsmith-ee
    container_name: appsmith
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./stacks:/appsmith-stacks
    restart: unless-stopped

Appsmith runs on a single container (Community Edition). The stack volume contains all application data — back it up regularly.

Resource requirements: 2GB RAM minimum, 4GB recommended. Appsmith handles background task processing within the container.

Configure Your Domain

Set APPSMITH_CUSTOM_DOMAIN in your environment to your domain. Appsmith handles SSL via Let's Encrypt automatically.

# In docker.env or compose environment
APPSMITH_CUSTOM_DOMAIN=tools.yourdomain.com

Set Up Authentication

Appsmith Community Edition supports email/password authentication by default. For SSO, Appsmith Business Edition supports SAML, OAuth2, LDAP, and OIDC.

If you need SSO similar to Retool's SSO, upgrade to Business Edition or use Appsmith Community with a reverse proxy handling authentication.

Step 3: Migrate Datasources (Resources)

Retool Resources become Appsmith Datasources. This is the easiest part of the migration.

Connect Databases

In Appsmith, go to Datasources → New Datasource. Create connections for each database your Retool apps use:

PostgreSQL:

• Host, Port, Database name, Username, Password
• Appsmith securely stores credentials

MySQL:

• Same fields as PostgreSQL

MongoDB:

• Connection string or individual fields

REST APIs:

• Base URL, Authentication (Bearer token, Basic auth, OAuth2, API key)
• Common headers shared across requests

Test each datasource connection before building apps on top of it.

Document API Differences

Retool and Appsmith handle API authentication slightly differently. If your Retool app uses OAuth2 connections (Salesforce, Google Sheets, etc.), reconfigure those integrations in Appsmith — the credential format differs even though the underlying service is the same.

Step 4: Rebuild Apps in Appsmith

The rebuild process follows a consistent pattern for each app:

Create Application Structure

1. Create a new Application in Appsmith
2. Add Pages to match your Retool app's sections (each Retool app becomes one or more Appsmith pages)
3. Set up the page layout — Appsmith uses a canvas where you drag-and-drop widgets

Mapping Retool Widgets to Appsmith Widgets

Retool Component	Appsmith Widget
Table	Table
Form	Form widget or manual form layout
Text Input	Input Widget
Select	Select Widget
Button	Button Widget
Container	Container Widget
Chart	Chart Widget
Modal	Modal Widget
JSON Explorer	JSON/Form View

Most core components have direct equivalents. Some Retool premium components (native mobile components) have no Appsmith equivalent.

Migrate Queries

Retool queries (SQL or API calls) become Appsmith queries within each page.

In Appsmith:

1. Select your datasource
2. Write the SQL or configure the API request
3. Name the query (reference it in widgets with queryName.data)

Retool query pattern:

// Retool: query.data returns results directly
{{ table.selectedRow.id }}

Appsmith equivalent:

// Appsmith: queries accessed via query.data
{{ Table1.selectedRow.id }}

Migrate JavaScript Logic

Retool allows inline JavaScript in almost every field. Appsmith uses JS Objects for reusable logic:

Retool inline JS:

{{ formatCurrency(query1.data[0].revenue) }}

Appsmith JS Object:

// Create a JS Object named "Utils"
export default {
  formatCurrency: (value) => {
    return new Intl.NumberFormat('en-US', {
      style: 'currency',
      currency: 'USD'
    }).format(value);
  }
}

// Reference in widget: {{ Utils.formatCurrency(Query1.data[0].revenue) }}

Move complex logic into JS Objects rather than keeping it inline — better organization and reusability.

Handle Retool Modules → Appsmith Packages

Retool Modules (reusable component groups) map to Appsmith Packages. Packages are available in Appsmith Business Edition.

If you're using Community Edition, recreate module functionality by:

• Copying widget groups across pages manually
• Using JS Objects for shared logic
• Documenting reusable patterns for your team

Step 5: Replicate Permissions

Retool has granular app-level and group-level permissions. Appsmith's permission model:

• Workspace-level: Admins, Developers, Viewers
• Application-level: Public, Workspace access, or private
• Page-level: Show/hide pages per user group (Business Edition)

If your Retool apps have complex role-based access (different departments see different data), you'll need Appsmith Business Edition or implement data-level access control in your query logic.

Example: Show admin controls only to admin users:

// Widget visible condition in Appsmith
{{ appsmith.user.email === 'admin@company.com' || appsmith.user.groups.includes('admins') }}

Step 6: Migrate Retool Workflows to Appsmith Workflows

Retool Workflows (automated multi-step processes triggered by events or schedules) have an Appsmith equivalent in Appsmith Workflows.

Key differences:

• Retool Workflows: visual node editor, each node is a query or JS block
• Appsmith Workflows: similar visual editor with triggers (webhook, schedule) and action steps

For each Retool Workflow:

1. Identify the trigger (webhook, schedule, database change)
2. Map the steps to Appsmith Workflow actions
3. Port JavaScript logic from Retool's JS nodes to Appsmith's JS steps
4. Test with sample inputs before going live

Complex Retool Workflows with many branches may be better migrated to a dedicated workflow tool (n8n, Kestra, or Windmill) rather than Appsmith Workflows.

Step 7: Test Before Cutover

Before switching users to Appsmith:

Functional Testing Checklist

• All datasources connect and return correct data
• Create/Read/Update/Delete operations work as expected
• JavaScript logic produces same outputs as Retool equivalents
• Permissions allow the right users to see the right data
• Workflows trigger correctly and produce expected results

User Acceptance Testing

• Invite 2-3 power users to test the Appsmith version alongside Retool
• Run both versions in parallel for 1-2 weeks
• Collect feedback on missing functionality

Performance Check

• Appsmith self-hosted performance depends on your server spec
• If queries are slow, check database indexing and Appsmith's query timeout settings

Step 8: Cutover

Communicate the Change

• Announce the migration date to all affected users at least 1 week in advance
• Provide a brief guide on any UI changes they'll encounter
• Designate a point of contact for questions

DNS/URL Update

If Retool was at retool.company.com, point that domain to your Appsmith instance to minimize URL disruption for users.

Keep Retool Available Briefly

Keep your Retool subscription active for 2-4 weeks post-cutover as a fallback. Once all users are comfortable in Appsmith and no critical workflows are missing, cancel Retool.

Cost Savings Summary

For a team of 5 builders + 50 end users:

Platform	Annual Cost
Retool Team	$5,400
Retool Business	$14,700
Appsmith Cloud (Business)	$1,440
Appsmith self-hosted	$78

Self-hosting Appsmith on Hetzner CPX21 ($6.50/month) saves $5,322-14,622/year versus Retool at comparable team sizes.

What You Might Miss from Retool

Be realistic about the differences:

Retool advantages not fully replicated:

• Native mobile app builder (Appsmith has no mobile equivalent)
• Server-side JavaScript execution (Appsmith runs JS client-side)
• Some niche data connectors (Retool has 70+ vs Appsmith's 45+)
• More polished out-of-box experience for new users

If your team heavily uses Retool's mobile app builder, Appsmith is not the right migration target — consider alternatives like Budibase or Tooljet.

Maintaining Self-Hosted Appsmith Over Time

Migrating to Appsmith is the one-time cost. The ongoing operational cost is maintaining the self-hosted deployment — and this is where many teams underestimate the commitment.

Updates: Appsmith releases frequently (typically every 2–3 weeks). Each release brings bug fixes and new features, but also occasionally introduces breaking changes in the widget API or query interface. The recommended update cadence is monthly: pull the new images, run the update script, verify your critical apps still function, then continue. Don't skip more than 2–3 versions or the migration scripts can create database issues.

Backups: Appsmith's data lives in MongoDB. A daily MongoDB dump is the minimum viable backup strategy:

# Daily backup cron
0 2 * * * docker exec appsmith-mongodb mongodump --out /backups/$(date +%Y%m%d)

Keep 7 days of daily backups and one monthly snapshot. If Appsmith's MongoDB instance goes down without a backup, you lose all apps, datasources, and user data. This has happened to teams, and recovery without a backup is not possible.

Performance at scale: Appsmith's default Docker Compose deployment runs the Appsmith server, MongoDB, and Redis in containers on a single machine. For deployments with 50+ users accessing apps simultaneously, the MongoDB instance can become a bottleneck. Signs of this: app loading feels slow even when queries return fast, and the Appsmith server logs show MongoDB connection timeouts. The resolution is either moving MongoDB to a dedicated instance or increasing server memory. Appsmith recommends 4 vCPUs and 8GB RAM for team-sized deployments.

Datasource credentials rotation: When you rotate a database password, every Appsmith datasource connected to that database needs updating. This is a manual process in Appsmith's UI — there's no bulk credential update. For teams using a secrets manager like Infisical or Vault, this is a known gap: Appsmith doesn't currently support pulling credentials from external secrets stores, so rotations require manual updates.

The decision between Appsmith and its closest alternatives (Tooljet, Budibase) often comes down to the widget library and the team's technical depth. The SaaS subscription audit framework helps quantify what you're actually saving when replacing Retool. For teams going beyond internal tools to build full product workflows, the indie hacker guide to building on open source covers the complementary stack — auth, payments, email, analytics — that usually accompanies an internal tool builder in production. For the server infrastructure decisions, the VPS comparison for self-hosters covers which providers offer the best price-to-performance ratio for MongoDB-heavy workloads like Appsmith.

Find More Internal Tool Alternatives

Browse all Retool alternatives on OSSAlt — compare Appsmith, Tooljet, Budibase, Directus, and every other open source internal tool builder with deployment guides and feature comparisons.