Migration snapshot
ActivePlatform
an Appsmith
Active and independent as of 2026 — frequent releases, launched agentic 'Appsmith Agents' in 2025–2026, no acquisition (github.com/appsmithorg/appsmith). Apache 2.0 Community Edition has no user cap and no license fee. Enterprise Edition is separate commercial (~$25/user/mo). Billing moved from hourly to flat per-user in 2025/2026.
Typical timeline
6–10 weeks
Typical cost
$13K–$25K (agency, fixed)
Why teams leave an Appsmith
Appsmith CE is legitimately good and genuinely free. Migration is worth considering only when specific friction points — Enterprise feature costs or self-host ops overhead — exceed the drag-drop convenience.
Per-user cost on cloud
Business ~$15/user/mo, Enterprise ~$25/user/mo. At 30+ users this rivals the cost of maintaining a custom Next.js admin stack. Run the 12-month headcount math before deciding.
SSO/RBAC gated behind Enterprise
Custom RBAC is gated to Business tier. SAML/OIDC SSO and SCIM are gated to Enterprise ($25/user/mo) — even on self-hosted CE, commercial features require a license key. If your compliance posture requires SSO, you're on a per-user cost treadmill.
App definitions non-portable
Apps export as JSON (via Git integration, available free) but run only on the Appsmith runtime (cloud or self-hosted Docker/K8s). Exit means a full rebuild regardless of what you export — the JSON is a migration spec, not runnable code.
Self-host ops overhead
Appsmith self-host requires Docker/Kubernetes + MongoDB (for app definitions) + Redis. If your team doesn't have Kubernetes experience, this is more ops overhead than a Next.js + Supabase stack that deploys to Vercel.
Air-gapped and embedding needs
CE self-host supports air-gapped only on Enterprise. Private app embedding is also Enterprise-gated. If these are requirements, you're on the Enterprise pricing path regardless of how you self-host.
What can you actually take with you?
Your source data is always in your own databases — Appsmith is a query/display layer only. App definitions export as JSON via Git but have no source-code eject path.
| Asset | Can you export it? | How | Notes |
|---|---|---|---|
| Data | Yes | Data lives in your own connected databases (Postgres, MySQL, MongoDB, REST APIs) — Appsmith is a query/display layer only; your source data is already yours | Appsmith never stores your application data |
| Code | No | Apps export as JSON config via Git version control (free on all tiers — GitHub/GitLab/Bitbucket); apps run only in the Appsmith runtime | Git sync gives version history, not source code; the JSON is a migration spec only |
| Design/UI | No | Component layout is Appsmith-proprietary; no HTML or React export | Screenshot every page and widget state for parity specification |
| Logic/Workflows | No | JS functions and query logic are embedded in Appsmith app JSON; must be translated to code | JS functions embedded in widget properties are easy to miss — requires a systematic widget-by-widget audit of the JSON export |
| Users & Auth | Partial | User list manageable via admin panel; SSO config (if Enterprise) is managed by your identity provider and is provider-side portable | Password hash export is not documented; SCIM provisioning setup is not portable as-is |
| Datasources | Yes | Datasource connection details (type, host, credentials) are visible in Appsmith's datasource settings and in the JSON export | Connection strings move to .env / Vercel environment variables in the new stack |
Swipe the table sideways to see the full breakdown.
Where each piece moves in code
The target stack is Next.js (App Router) + Supabase/PostgreSQL — eliminating the MongoDB + Redis self-host dependency and the Enterprise feature gate.
an Appsmith
Appsmith pages (multiple pages per app)
In code
Next.js app directory pages with server-side auth guard in middleware
Each Appsmith page becomes a Next.js route; auth guard replaces Appsmith's role-based page access
an Appsmith
Appsmith queries (SQL, JS, REST API)
In code
Supabase queries via Drizzle or direct Postgres client; REST via Next.js Route Handlers
Extract SQL from JSON export; refactor into typed server-side functions
an Appsmith
Appsmith widgets (tables, forms, modals, charts)
In code
shadcn/ui + Recharts + Radix UI in React
Rebuild widget by widget using screenshots as parity spec
an Appsmith
Appsmith JS functions (business logic in widgets)
In code
React hooks + Next.js Server Actions
Move to Server Actions where possible; keep client-side hooks only for UI state
an Appsmith
Appsmith datasources (DB connections, REST APIs)
In code
Supabase + environment-variable–secured server-side fetch in Route Handlers
Connection strings move from Appsmith datasource config to .env / Vercel env vars
an Appsmith
Appsmith RBAC (user groups, page permissions)
In code
Supabase RLS + role column; Next.js middleware for route guards
Document all role/permission combinations per page before migration
an Appsmith
Appsmith workflows (triggers, approvals)
In code
Supabase Edge Functions or Next.js Route Handlers with Vercel Cron
Map every trigger type and approval flow step before writing Edge Functions
an Appsmith
Self-hosted Appsmith (Docker + MongoDB + Redis)
In code
Vercel + Supabase cloud, or self-hosted Next.js + Postgres
Eliminates MongoDB ops overhead; Supabase handles the entire backend
The migration roadmap
Plan 6–10 weeks. The critical early step is using Git export to get a complete JSON blueprint of all apps before starting any rebuild work.
Extraction & Audit
Week 1- Enable Git integration (free tier) and export all app JSON to a GitHub/GitLab repo
- Audit all datasource connections — document type, host, credentials, and confirm external accessibility
- List every page and every query across all apps — this is your migration scope
- Identify which users are on built-in auth vs Google OAuth
- Evaluate Appsmith CE self-host as a cost-free alternative before committing to full code migration
Watch out: JS functions embedded in widget properties are easy to miss in a JSON review — audit widget by widget, not just at the query level
Foundation Setup
Week 1–2- Scaffold Next.js (App Router) + Supabase project
- Migrate datasource connection strings to environment variables
- Set up Supabase RLS schema mirroring Appsmith user groups and page permissions
- Configure SSO provider redirect URLs if migrating from Enterprise SSO
Query & Logic Migration
Week 2–5- Extract SQL queries from JSON export; refactor into typed Drizzle/Supabase service functions
- Port Appsmith JS functions to React hooks and Server Actions
- Rebuild workflow triggers and approval flows as Supabase Edge Functions or Route Handlers
- Implement server-side auth guard in Next.js middleware
Watch out: If any Enterprise features (SAML, SCIM, custom RBAC) are in active use, map these requirements to the new auth provider before building
UI Rebuild
Week 4–8- Rebuild pages with shadcn/ui + Recharts, page by page, using screenshots as spec
- Implement data tables, forms, modals, and charts
- Validate each page against the screenshot spec before moving on
- Test role-based access control against all documented permission sets
Parallel Run & Cutover
Week 8–10- Run Appsmith and new app in parallel; validate all data operations
- Force password reset for built-in email/password users
- Update SSO redirect URLs at identity provider
- Decommission Appsmith subscription or self-host after all teams confirm parity
Three ways to migrate — honestly
Every path has a real trade-off. Here is what each costs, how long it takes, and where it bites.
DIY (with AI tools)
$0–500 + your time
3–5 months part-time
Fits
Developers comfortable with Next.js and Supabase who have simple apps (3–5 pages, external Postgres/REST data, no SSO/SCIM requirements)
Risks
JS functions embedded in widget props are easy to miss; AI tools accelerate UI but don't auto-migrate business logic; MongoDB self-host removal needs careful planning if self-hosted
Freelancer
$4K–10K
6–10 weeks
Fits
Apps with moderate complexity (10–20 pages, multiple datasources, basic workflows); freelancer must understand Appsmith JSON structure and Supabase RLS
Risks
Single-point-of-failure; Enterprise SSO/SCIM migration complexity may be quoted separately; no fixed-price guarantee
Agency (RapidDev)
Done-for-you$13K–25K fixed price
6–10 weeks
Fits
Apps with 10–30+ pages, complex queries, SSO/SCIM, workflow approvals, or teams that need guaranteed parity and a managed MongoDB-to-Supabase cutover
Risks
Highest upfront investment; evaluate whether 12-month Enterprise license costs cover the project cost — book a free scoping call at rapidevelopers.com
The real risks — and how to defuse them
JS logic dispersal
Mitigation: JS functions embedded in Appsmith widget properties are easy to miss in a JSON export. Conduct a systematic widget-by-widget audit of every page — not just a grep for query names.
MongoDB ops debt on self-host
Mitigation: Appsmith's self-hosted MongoDB is purely for app definitions — you're running a database just to store UI configs. Include the MongoDB decommission in your migration plan; it's not automatic.
Enterprise feature dependency
Mitigation: If SAML/SCIM on Enterprise is in active use, ensure your new auth provider (Supabase + external IdP) supports the same user provisioning flow before cutover. Map SCIM attributes explicitly.
Auth reset for built-in users
Mitigation: Built-in email/password users need a forced password reset on migration to the new platform. Identify these users in advance and plan the reset communication before cutover.
Should you actually migrate?
Migrating is a real project. Sometimes staying is the right call — here is the honest split.
Stay if
- You're on Apache 2.0 CE self-host with no user cap and no SSO/SCIM need — it's genuinely free, actively maintained, and has no license-key dependency
- Your apps are CRUD over external Postgres/REST and the drag-drop UI saves real dev time with no customer-facing UI requirement
- Team is small enough that per-user cost is not a factor and Git sync is sufficient for version control
Migrate if
- You need SAML/OIDC SSO or SCIM and Enterprise pricing ($25/user/mo) is approaching custom-stack economics at your headcount
- You need customer-facing UI beyond Appsmith's internal-tools aesthetic
- Your ops team wants to eliminate the MongoDB + Redis self-host dependency entirely from your infrastructure
Our honest verdict
Appsmith CE is one of the best-positioned open-source internal-tool platforms (Apache 2.0, no user cap). Migration is rational only when Enterprise feature costs or self-host ops burden exceed the value of the drag-drop builder — and worth checking CE self-host as a first step before committing to a full code migration.
Do this today: pre-migration checklist
Whatever path you choose, protect yourself first. Work through this before you touch a line of code.
Enable Git integration (free tier) and export all app JSON to a repo before starting
The JSON export is your complete migration spec — every page, query, and widget definition is in this file
Audit all datasource connections — document type, host, credentials, and confirm external accessibility
Datasources are the connective tissue; missing or inaccessible ones block the rebuild entirely
List every page and every query across all apps
This is your migration scope — the number of pages and queries determines the timeline and cost estimate
Identify which users are on built-in auth vs Google OAuth
Google OAuth users migrate cleanly; built-in password users need a forced reset flow planned in advance
Evaluate Appsmith CE self-host as a cost-free alternative before committing to full code migration
If cost is the only trigger and you're on cloud, CE self-host may solve the problem without a full rebuild
Check if any Enterprise features (SAML, SCIM, custom RBAC) are actively used
Enterprise feature usage adds significant migration complexity and affects the new auth provider choice
Frequently asked questions
Can I export my Appsmith app as source code?
No. Appsmith apps export as JSON configuration via Git integration (free on all tiers). This JSON runs only inside the Appsmith runtime — it is not standalone runnable code. The JSON is useful as a migration specification: every page, query, and widget definition is readable in it.
What data can I take with me when leaving Appsmith?
All of it. Appsmith is a query/display layer — your application data lives in your own connected databases (Postgres, MySQL, MongoDB, REST APIs). Appsmith never stores your source data. Datasource connection details are also readable in the JSON export and Appsmith settings.
How long does an Appsmith migration take?
Typically 6–10 weeks. Simple apps with 3–5 pages over external Postgres can be done in 4–6 weeks. Apps with 20+ pages, complex JS widget logic, and Enterprise SSO/SCIM requirements reach 10 weeks. The main time sinks are auditing JS functions embedded in widget props and rebuilding approval workflows.
What happens to my users and passwords when I migrate?
Google OAuth users migrate cleanly — no password involved. Built-in email/password users will need a forced password reset on the new platform; password hash export is not documented. Enterprise SSO users (SAML/OIDC) need redirect URL updates at the identity provider; SCIM provisioning must be recreated.
Is Appsmith CE really free — or are there hidden costs?
Apache 2.0 CE is genuinely free — no user cap, no license fee, no phone-home activation. Commercial features (SAML SSO, SCIM, custom RBAC) require a license key even on self-hosted CE. If you don't need those features, CE is a legitimate long-term free option and worth evaluating before committing to a full code migration.
Should I migrate to code or to Appsmith CE self-host?
If cost is your only trigger and you're on Appsmith Cloud, migrating to CE self-host is the fastest and cheapest move — no app rebuild needed, and CE is Apache 2.0 with no per-user fee. Move to code only when MongoDB + Redis ops overhead is the problem, or when Enterprise features are required and their cost exceeds a custom stack.
What is the hardest part of migrating from Appsmith?
Two things: JS functions embedded in widget properties (easy to miss without a systematic per-widget JSON audit) and the self-hosted MongoDB decommission (which requires careful timing relative to the app cutover). The UI rebuild itself is predictable once you have the JSON export and screenshots.
How much does an Appsmith migration cost, and can RapidDev help?
DIY with AI tools: $0–500 plus 3–5 months part-time (works for simple CE self-host migrations). Freelancer: $4K–10K over 6–10 weeks. Fixed-price agency: $13K–25K over 6–10 weeks. RapidDev offers fixed-price Appsmith migrations with a free scoping call at rapidevelopers.com — useful for apps with complex query logic or Enterprise SSO requirements.
We migrate no-code apps to production code
- Fixed price — $13K–$25K (agency, fixed)
- No data loss, no downtime
- You own 100% of the code
30-min call. Quote within 48 hours.