The Zeroic Journal

When to leave FlutterFlow for code and when to stay

The four signs a FlutterFlow app has outgrown the builder, and how to move to code while keeping your users, data and store listings.

On this page 5 sections
  1. When to leave FlutterFlow: the four signs
  2. What the FlutterFlow export gives you
  3. How to move without losing users or listings
  4. How to decide in five bullets
  5. How WordUp Tutoring keeps shipping on code it owns

Leave FlutterFlow when one of four signs shows up: custom code fights the builder, changes can’t be reviewed before release, releases depend on one person, or you want one team for web and mobile. Until then, stay. The move is smaller than it looks: FlutterFlow generates standard Flutter code, and GitHub push starts on the $80-a-month Pro plan.

FlutterFlow is a fast way to get an app onto phones, and it keeps getting better. In the last three months alone its changelog added Supabase upserts and RPC calls (August 13, 2026), try/catch error handling (September 2), RevenueCat paywalls (September 24) and a move to Flutter 3.47.1 (October 6). The flip side is that those changes land in your app on FlutterFlow’s schedule. On October 20, 2026, FlutterFlow removed support for the retired Firebase Dynamic Links service. That’s fine while the builder matches how your team works. This piece is about the point where it stops matching, and how to leave without losing users, data or store listings.

When to leave FlutterFlow: the four signs

One sign means start planning. Two or more, and the decision is already made.

Custom code fights the builder. FlutterFlow supports custom functions, actions, widgets and code files, and that’s the right escape hatch for one or two features. The custom code docs list the limits: custom functions can’t add their own imports, custom widgets can’t return a value, and widgets don’t preview in the builder until they’re compiled. When most of your new features ship as custom actions and widgets, you’re paying for a visual builder your engineers mostly route around.

Changes can’t be reviewed. In a code team, every change is a pull request someone reads before it ships. In FlutterFlow, the change is a set of edits in the builder. FlutterFlow can push the generated code to GitHub, but it pushes to a branch called flutterflow and overwrites it on every push. A reviewer sees the generated output after the edit has been made, with no record of why. For a two-person team that’s workable. For a team with a compliance customer or a security questionnaire to answer, it isn’t.

Releases depend on one person. When the release is a button in one person’s FlutterFlow account, so is the knowledge of what shipped and how it was signed. If that person is on holiday or leaves, nobody else can ship a fix with confidence. A release pipeline that any engineer can run, from a tagged commit, removes that risk.

You want one team for web and mobile. If your web app is React or Next.js, a FlutterFlow mobile app means two skill sets, two places to change a feature and two release rhythms. Moving the mobile app to React Native lets one React team cover both.

If none of these are biting yet, stay. Rebuilding to get features FlutterFlow already ships is money spent on nothing your users will see. If you’re staying but need more hands, FlutterFlow developers who also write plain Flutter can carry the custom code without fighting the builder.

What the FlutterFlow export gives you

The good news: you’re not starting from zero. FlutterFlow generates Flutter code, and as of November 11, 2026 its pricing page puts source code download on the Basic plan ($39 a month) and GitHub push on Pro ($80 a month, up to 2 editors and 2 branches beyond main) and Max ($150 a month, up to 5 editors and 5 branches).

FlutterFlow’s own GitHub workflow tells you how far the export goes. You create a develop branch from flutterflow, put custom code there, and merge each new builder push into it with a pull request, resolving conflicts as you go. The docs warn against editing the flutterflow branch directly, because the next push overwrites it. They describe code moving from the builder into GitHub and say nothing about the reverse.

That defines the decision. The export gives you:

  • A working Flutter app you can build and run outside the builder from day one.
  • Your custom code, already in Dart, which carries over as is.
  • Your screens and navigation, so the new codebase starts with the product your users know.

What it doesn’t give you is a codebase your team designed. The structure is whatever the builder generated, including every workaround the first sign above produced. Once your engineers start making most changes in code, the builder stops being the source of truth, and keeping both in sync becomes the work. That’s the fork point. Pick it on purpose.

How to move without losing users or listings

Most of the risk in leaving FlutterFlow sits in the four things users notice: their account, their data, the app on their phone and the links that open it.

  1. Keep the backend where it is. Your Firebase or Supabase project stays. The new app connects to the same auth and the same database, so nobody re-registers and no data moves. If the backend itself is the problem, move it later, as a separate step. Our Supabase vs Firebase cost breakdown covers when that’s worth it.

  2. Keep the same app identity on both stores. On iOS, the bundle ID can’t be changed after you upload a build and must match the one in the Xcode project. On Android, the system compares signing certificates before installing an update; sign with a different certificate and you need a different package name, so users install it as a brand-new app. Ship the new codebase as an update to the existing listings, and your reviews, ratings and installs stay with you.

  3. Get the signing setup out of the builder first. Before anyone writes code, confirm who holds the Apple developer account, the Play Console, and the Android upload key. With Play App Signing, Google holds the app signing key, and a lost upload key can be reset in the Play Console. Without it, a lost signing key means you can’t update the app at all.

  4. Plan the deep links. Firebase shut down Dynamic Links on August 25, 2025, and FlutterFlow replaced them with its own FlutterFlow Dynamic Links on October 6, 2026. If your invites, password resets or marketing links use them, check what happens to those links once you stop building in FlutterFlow, and set up iOS Universal Links and Android App Links in the new app before cutover.

  5. Choose Flutter or React Native once. Staying on Flutter keeps the most of what you have: the exported Dart code becomes the starting point. React Native means a rebuild of the screens, worth it when your web team already works in React. Either way, the backend and store listings don’t change.

  6. Move it one piece at a time. Ship the new build to internal testers, then a staged rollout, then everyone. The same thinking applies as in our guide on when to rebuild a Bubble app: no freeze, no big-bang rewrite. FlutterFlow already hands you Flutter code, so there is less to rebuild.

How to decide in five bullets

  • Standard screens, Firebase or Supabase, one or two people building. Stay on FlutterFlow. Ship features.
  • A handful of custom widgets, the rest in the builder. Stay, and use the develop branch workflow on Pro so custom code lives in Git.
  • Most new features ship as custom code. Plan the move. Export to GitHub now so the code history starts building.
  • A customer, investor or auditor asks how changes are reviewed. Move. A reviewable pull request is the answer they want.
  • Your web app is in React and you’re hiring for it. Move the mobile app to React Native so one team covers both.

How WordUp Tutoring keeps shipping on code it owns

WordUp Tutoring is a learning app for K-8 students: daily challenges, homework help, reading support and learning games. We built it as one fixed-scope project on Next.js and Supabase, with sign-in by email or Google and a separate way in for students, then built the AI into the product. WordUp then moved to a retainer, and the work has continued in the same codebase, with the hours flexing to the roadmap.

That’s the point of leaving FlutterFlow at the right moment: when the roadmap keeps growing, the product lives in a repository any engineer can pick up, with a release process behind it, not in one person’s builder login.

We run FlutterFlow moves as a FlutterFlow migration under our Code Rescue engagement. A senior engineer reviews the exported code, backend and release setup first. One fixed price, agreed after the review. Code Rescue blocks start at $6,000 and run 2-4 weeks. If you’re not sure the move is warranted yet, a Performance or Security audit tells you what’s slowing the app down before you commit. Leaving another platform too? See all our migrations.

Frequently asked questions

Can I export my code from FlutterFlow?
Yes. FlutterFlow generates standard Flutter code. As of November 2026, downloading the source starts on the Basic plan at $39 a month, and pushing it to a GitHub repository starts on Pro at $80 a month. FlutterFlow pushes to a branch called flutterflow and overwrites it on every push, so your own changes belong on a separate branch.
Will users have to reinstall the app after leaving FlutterFlow?
No, as long as the new build keeps the same bundle ID on iOS and the same package name and signing key on Android. Apple doesn't let you change the bundle ID after a build is uploaded, and Android only installs an update signed with a matching certificate. Ship the new code as an update to the existing listings.
Should I rebuild a FlutterFlow app in Flutter or React Native?
Stay on Flutter if you want to keep the most of what you have, because the exported Dart code becomes your starting point. Choose React Native if your web app and your team already work in React and you want one team covering web and mobile. Either way, keep the backend and store listings exactly as they are.
Can I keep using FlutterFlow after exporting the code?
For a while. FlutterFlow's documented workflow pushes builder changes to one branch and has you merge them into a develop branch that holds your custom code. That works while most changes still start in the builder. Once most changes are made in code, the builder stops being the source of truth and the merges become the work.
Is FlutterFlow good enough for a production app?
Yes, for many apps. A FlutterFlow app with standard screens, a Firebase or Supabase backend and a small team can run in production for years. It stops fitting when custom code starts fighting the builder, changes can't be reviewed before release, releases depend on one person, or you want one team across web and mobile.

References

  1. FlutterFlow docs - Push to GitHub repo
  2. FlutterFlow docs - Custom code
  3. FlutterFlow - Pricing
  4. FlutterFlow - Changelog
  5. Firebase - Dynamic Links deprecation FAQ
  6. Android Developers - Sign your app
  7. Apple - App Store Connect app information

More from the journal

Hear from Khushi within 24 hours.

Khushi Arora Partner @ Zeroic

Is your FlutterFlow app fighting the builder? We move FlutterFlow apps into a Flutter or React Native codebase you own, with the same backend, users and store listings. Start with a review by a senior engineer.

See Code Rescue, or book a 30-minute call