Migration snapshot
ActivePlatform
a AppMaster
AppMaster is an operating no-code platform with genuine code generation (Go/Vue/Kotlin/Swift). Full source-code export is available on Enterprise tier only; Business/Business+ clients receive binaries. The platform regenerates all code from the visual model on each publish, meaning hand-edits to generated files are overwritten.
Typical timeline
6–10 weeks
Typical cost
$13K–$25K (agency, fixed)
Why teams leave a AppMaster
AppMaster is the most honest code-generator in the low-code market — it produces real, runnable source. The migration calculus depends entirely on your plan tier and your team's language skills.
Source export requires Enterprise tier
Only Enterprise clients receive actual Go/Vue/Kotlin/Swift source. Business/Business+ clients get binaries only — migrating a binary is a full rebuild. Verify your plan tier before assuming you have exportable code.
Generated code regenerates on every publish
AppMaster regenerates all code from the visual model on each publish; any hand-edits to generated files are overwritten. Post-export maintenance requires understanding the Go/Vue codebase, not the visual model.
Scaling cost on Enterprise tier
Enterprise tiers with source export are priced for larger organisations. As apps grow, platform costs escalate faster than custom-code maintenance costs, making an exit increasingly rational.
Vendor dependency for build pipeline
Even with source export, the normal AppMaster workflow uses the platform's build pipeline. Exiting means establishing your own CI/CD, Docker, and deployment infrastructure — an upfront investment that pays off over time.
Go backend skill requirement
AppMaster generates a Go backend. Post-migration the team needs Go developers, not AppMaster specialists. If the team is TypeScript-native, budget a Go-to-TypeScript rewrite in the migration scope.
What can you actually take with you?
Enterprise tier gives you a genuinely clean export — Go backend, Vue3 frontend, Kotlin/SwiftUI mobile, OpenAPI docs, and DB migrations are all included. Below Enterprise, you receive binaries only, which is effectively no export.
| Asset | Can you export it? | How | Notes |
|---|---|---|---|
| Data | Yes | PostgreSQL-compatible backend; standard pg_dump; AppMaster generates DB migration scripts as part of the build process — these are also exportable with source | Data is fully yours regardless of plan tier |
| Code | Partial | Enterprise only: full runnable source — Go (Golang) backend (stateless, PostgreSQL-compatible), Vue3 + JS/TS web frontend, Kotlin/Jetpack Compose (Android), SwiftUI (iOS) via server-driven framework | Business/Business+ tiers: binaries only — full rebuild required; Enterprise: full runnable source |
| Design/UI | Partial | Vue3 components are in the exported source (Enterprise); the visual design model itself is not separately exportable | Post-export UI changes require Vue3 development skills; the visual editor design is not extractable as a standalone artefact |
| Logic/Workflows | Partial | Enterprise only: Go backend contains all business logic; auto-generated Swagger/OpenAPI docs included; customisation must happen at defined hook points to survive republishing | Freeze the AppMaster version before export; do not republish after beginning migration or hand-edits will be overwritten |
| Users & Auth | Partial | Auth logic in exported Go backend; a PostgreSQL dump will include the user table with whatever hash format AppMaster uses | Password hashes not documented as separately exportable by AppMaster; verify hash format against Supabase Auth import requirements |
Swipe the table sideways to see the full breakdown.
Where each piece moves in code
Enterprise exports land on Go (backend) + Vue3 (web) + Kotlin/SwiftUI (mobile); the recommended migration path standardises the web layer on Next.js + Supabase while keeping or upgrading the mobile apps natively.
a AppMaster
AppMaster visual data model
In code
PostgreSQL schema (Supabase)
Already PostgreSQL-compatible; migrate the existing DB with pg_dump/restore
a AppMaster
AppMaster Business Processes (BP)
In code
Exported Go service functions → Next.js Server Actions or API Route Handlers
Maintain in Go or rewrite in TypeScript if the team is TypeScript-native
a AppMaster
AppMaster Web App (Vue3)
In code
Next.js + React components
Migrate to Next.js if standardising the stack; or maintain/extend the exported Vue3 app independently
a AppMaster
AppMaster Mobile (Kotlin/SwiftUI)
In code
Android Studio (Kotlin/Jetpack Compose) + Xcode (SwiftUI)
Maintain the exported native apps in their respective IDEs; export signing certs and keystores before leaving AppMaster
a AppMaster
AppMaster API endpoints
In code
Exported Go REST handlers + Swagger docs → Next.js API Routes
OpenAPI spec is the authoritative API contract; archive it as part of the migration handoff
a AppMaster
AppMaster Scheduled Jobs
In code
Supabase pg_cron or standalone Go cron service
Already in exported Go code; map to pg_cron for simplicity or retain the Go scheduler
a AppMaster
AppMaster Auth
In code
Supabase Auth or keep Go auth layer
Plan password-hash portability; forced password reset may be needed if hash format is incompatible
a AppMaster
AppMaster file storage
In code
Supabase Storage or AWS S3
Migrate file references in the DB alongside file contents in object storage
The migration roadmap
The migration path splits immediately at plan tier. Verify whether you are on Enterprise (source export) or Business/Business+ (binary rebuild) in week 1 — everything else depends on this.
Tier verification and export
Week 1- Confirm AppMaster plan tier — Enterprise (source) or Business/Business+ (binaries)
- If Enterprise: request full source export (Go, Vue3, Kotlin, Swift, OpenAPI docs, DB migrations) before contract termination
- If Business/Business+: export the visual model documentation — screenshots of all Business Processes and data models; this becomes the rebuild specification
- Export PostgreSQL database with pg_dump for a clean baseline backup
- Freeze the AppMaster version — do not republish after beginning migration
Watch out: Republishing in AppMaster after starting the migration will overwrite any hand-edits made to the exported source
Environment setup and audit
Weeks 2–3- Stand up Next.js + Supabase project; configure CI/CD pipeline (this replaces AppMaster's build pipeline)
- Audit the exported Go backend: review service functions, API handlers, and hook points
- Confirm Apple Developer and Google Play Console account ownership if mobile apps are live on app stores
- Export API signing keys, certificates, and keystores from AppMaster before closing the account
- Run DB migration scripts in a staging environment; verify schema matches production
Backend port and data migration
Weeks 3–6- Port Go service functions to Next.js Server Actions or API Route Handlers (or maintain Go if the team has capacity)
- Apply DB migration scripts in order against the new PostgreSQL/Supabase instance
- Migrate file storage assets to Supabase Storage or S3
- Move scheduled jobs to Supabase pg_cron
- Implement Supabase Auth; plan password-hash migration or forced-reset flow
Watch out: DB migration script ordering is critical — run all scripts in sequence in staging before touching production
Frontend rebuild and UAT
Weeks 5–9- Build Next.js page components from Vue3 export or Business Process screenshots
- Implement mobile parity: extend Kotlin/SwiftUI apps to point at new backend
- Run UAT with business stakeholders; compare feature parity against AppMaster production
- Archive the OpenAPI spec as the authoritative API contract for the new system
Cutover and post-migration
Week 10- DNS cutover to the new Next.js deployment on Vercel
- Submit updated mobile app builds to app stores with new backend URLs
- Monitor error rates for 48 hours post-cutover
- Cancel AppMaster subscription after confirming the new system is stable
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 (self-directed with AI tools)
$0–$500 + your time
3–6 months part-time
Fits
Enterprise-tier clients with in-house Go or TypeScript developers who already understand the exported codebase
Risks
Go-to-TypeScript rewrite is non-trivial without strong backend experience; CI/CD setup from scratch adds time; mobile app store processes can stall progress
Freelancer
$4K–$12K
2–3 months
Fits
Simpler apps with a clean Enterprise source export and a well-documented Business Process inventory
Risks
Freelancers may not have experience with AppMaster's generated Go patterns; scope creep on the mobile layer is common
Agency (RapidDev)
Done-for-you$13K–$25K fixed
6–10 weeks
Fits
Teams on any tier who want a clean, fully-owned Next.js + Supabase codebase with CI/CD and no AppMaster dependency
Risks
Minimal — fixed price, defined scope, free scoping call to assess tier and export feasibility before contract
The real risks — and how to defuse them
Tier lock — no source on Business/Business+
Mitigation: Check plan tier in week 1; budget a full rebuild if binary-only. The visual model documentation (screenshots of BPs and data models) becomes the rebuild specification.
Go skill gap in the team
Mitigation: Assess team skills in week 1. If the team is TypeScript-native, include a Go-to-Next.js Server Actions rewrite in scope — this is a known, scoped effort, not an unknown.
Regeneration overwrite surprise
Mitigation: Freeze the AppMaster version before export. Do not republish after beginning migration — any republish overwrites the hand-edited generated files.
DB migration script ordering
Mitigation: AppMaster generates sequential DB migration scripts. Apply them in order in a staging environment first; verify schema matches production before running against live data.
Mobile app store continuity
Mitigation: Export signing certificates and keystores before leaving AppMaster. Confirm Apple Developer and Google Play Console account ownership is with the client. Account transfers can take 2–4 weeks.
OpenAPI spec not archived
Mitigation: The auto-generated Swagger/OpenAPI docs are the best specification of the backend. Export and archive them as part of the migration artefact handoff — they define every endpoint the frontend depends on.
Should you actually migrate?
Migrating is a real project. Sometimes staying is the right call — here is the honest split.
Stay if
- You are on Enterprise tier, actively building new features, and the visual model + code-generation cycle is faster than a traditional dev workflow for your team
- Your app is early-stage and the per-publish regeneration cycle suits your iteration speed — the platform overhead is worth it while the product is evolving rapidly
- Your team has no Go, Vue, Kotlin, or SwiftUI developers and the AppMaster visual workflow is the only way they can maintain the app — a migration would create a skills gap without addressing the root problem
Migrate if
- You are on Business/Business+ and hitting feature limits — you have no source export and will need to rebuild anyway; better to do it now than after more development investment
- You are on Enterprise and your app is stable or mature — the platform cost no longer buys you feature velocity; own the code and reduce the annual bill
- Your team wants to hire mainstream developers (TypeScript/React) rather than Go specialists — the exported Go codebase becomes a hiring constraint over time
Our honest verdict
AppMaster is the most honest code-generator in the low-code market — it produces real, runnable source. The catch is the Enterprise tier requirement. Below Enterprise, you are migrating from binaries, not source, and it is a full rebuild regardless.
Do this today: pre-migration checklist
Whatever path you choose, protect yourself first. Work through this before you touch a line of code.
Verify your AppMaster plan tier immediately
Source export is Enterprise only; Business/Business+ = binaries, which means a full rebuild — this changes the entire migration approach and budget
If Enterprise: request full source export before contract ends
The export package includes Go backend, Vue3 frontend, Kotlin, SwiftUI, OpenAPI docs, and DB migration scripts — all of it must be in your hands before you can close the account
If Business/Business+: export visual model documentation now
Screenshots of all Business Processes and data models are your rebuild specification; once the account is closed, this information is gone
Export the PostgreSQL database with pg_dump
Your data is yours regardless of plan tier; get a clean baseline backup before any migration work begins
Confirm Apple Developer and Google Play Console account ownership
Mobile apps on stores need verified ownership of the signing accounts; account transfers can take 2–4 weeks and can stall a deployment
Export API keys and signing certificates/keystores
These are required for rebuilding the CI/CD pipeline and maintaining mobile app builds; they cannot be recovered after account closure
Freeze the AppMaster version — do not republish after beginning migration
Republishing regenerates all code from the visual model and overwrites any edits made to the exported source
Frequently asked questions
Can I export my AppMaster app's source code?
Yes, but only on the Enterprise tier. Enterprise clients receive a full export: Go backend, Vue3 web frontend, Kotlin/Jetpack Compose (Android), SwiftUI (iOS), auto-generated OpenAPI docs, and database migration scripts. Business and Business+ clients receive binaries only — there is no source-code export on those tiers, and migrating from binaries requires a full rebuild.
What happens to my AppMaster data when I migrate?
Your data is fully portable regardless of plan tier. AppMaster uses a PostgreSQL-compatible backend, so a standard pg_dump gives you a complete database backup. The DB migration scripts generated by AppMaster are also exportable on Enterprise tier and document the schema history.
How long does an AppMaster migration take?
Enterprise tier with a clean source export: 6–10 weeks for a typical app. Business/Business+ requiring a full rebuild: 10–16 weeks depending on app complexity. The mobile layer (Kotlin/SwiftUI) and app store submission add 2–4 weeks to any timeline involving native mobile apps.
What happens to my users and passwords after migration?
Auth logic is in the exported Go backend, and the user table is accessible via pg_dump. Password hash portability depends on the format AppMaster uses — if incompatible with Supabase Auth's import format, a forced password reset for all users at cutover is the standard approach. Communicate this to users at least two weeks before the cutover date.
Is AppMaster shutting down?
No. AppMaster is an active platform with no shutdown signals as of mid-2026. The migration case is driven by plan-tier economics (Enterprise cost vs. feature velocity), language-skill fit (Go vs. TypeScript), and the desire to own the build pipeline rather than depend on AppMaster's regeneration cycle.
Can I keep the exported Go backend instead of rewriting to TypeScript?
Yes. The exported Go backend is a standard stateless Go service with PostgreSQL — it runs independently of AppMaster after export. If your team has Go developers, maintaining the Go backend while migrating the frontend to Next.js is a valid and often faster path than a full TypeScript rewrite.
How does RapidDev handle AppMaster migrations?
RapidDev offers a free scoping call to assess your plan tier, review the export package (or visual model documentation for Business/Business+), and scope the migration to a fixed price. Typical engagement: $13K–$25K, 6–10 weeks, with a fully-owned Next.js + Supabase codebase and CI/CD pipeline delivered at the end.
Do I need to keep AppMaster active during the migration?
For Enterprise clients, freeze and export first, then start migration work — you do not need an active account once the export package is in your hands. For Business/Business+ clients doing a rebuild, keep the AppMaster account active for reference access to the visual model until the new system is validated in UAT.
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.