Comparison
No-code or custom build: when should you move off Lovable, Bubble or a similar tool?
By Rare Agentics engineering teamLast updated First published 7 minute read
Stay on a no-code or AI app builder such as Lovable, Bolt or Bubble while you are still finding out what users want and the product holds no real customers' personal data. Move to a custom build, or harden what you have, when real customers, payments or personal data arrive, when the platform limits what you need to build next, or when an investor or buyer will look at the code. The move is rarely a rewrite from nothing: the product thinking, the data and often much of the code can be kept.
What is the difference between no-code and a custom build?
The tools have blurred, so it helps to be precise about the three things people mean.
Visual no-code platforms such as Bubble, Glide or Softr let you assemble an app from blocks inside the vendor's platform. The app runs on their infrastructure, and you usually cannot take the code away with you.
AI app builders such as Lovable, Bolt, Replit and v0 write real code from your prompts, often a React front end on a hosted database such as Supabase. You can usually export the code, but unless someone has reviewed it, nobody knows what it does at the edges, and the architecture is whatever the tool chose.
A custom build is software written and reviewed by engineers, in your own repositories, deployed to your own cloud accounts, with tests for the rules that must never break.
All three are legitimate. The question is which one fits the stage you are at.
How do they compare side by side?
| Visual no-code | AI app builder | Custom build | |
|---|---|---|---|
| Speed to a first version | Very fast | Very fast | Weeks: a first product typically takes 1 to 8 weeks |
| Who writes the code | The platform, hidden from you | An AI tool, unreviewed | Engineers, with every change reviewed |
| Can you take the code away | Usually not | Usually yes | Yes, it lives in your repositories |
| Security | The platform's defaults plus your settings (on Bubble, data stays visible until you write privacy rules for it) | Often gaps in access rules, keys and limits | Designed in, tested and reviewed |
| Performance at scale | Limited by the platform | Depends on choices nobody checked | Built for your expected load |
| Cost shape | Monthly plan, rising with usage | Monthly plan plus hosting | A fixed build price, then hosting in your accounts |
| Best for | Internal tools and early tests | Prototypes and first users | Real customers, payments and personal data |
When is staying on no-code the right answer?
Stay while you are learning. If you are still testing whether anyone wants the product, the speed of a no-code or AI tool is worth more than clean architecture. Changing a screen in an afternoon beats a perfect codebase for an idea nobody uses.
Stay, too, for internal tools with a handful of trusted users and no sensitive data. A tracker for your own team does not need the engineering a customer-facing product needs.
And stay if the product is working, the platform does everything you need, and nothing in the list below applies. Moving for its own sake is a cost with no return.
What are the signs it is time to move?
These are the triggers we see most often. One on its own may be manageable. Two or three together usually mean it is time.
- Real customer data arrives. Personal data brings duties under UK GDPR from your first real user, and health data is special category data with stricter rules. A breach that risks harm to people must be reported to the ICO within 72 hours of you becoming aware of it.
- You start taking payments. Money raises the stakes on every access rule and every limit.
- The platform says no. A feature you need is not possible, or only possible through a workaround that breaks every time the platform updates.
- Performance falls over. Pages slow down as data grows, or costs rise faster than usage.
- The AI tool starts breaking things. Each prompt fixes one thing and breaks another, because nobody holds the whole design in their head.
- Someone will look at the code. An investor's technical due diligence, an enterprise customer's security questionnaire or a buyer's review.
- You cannot hire for it. Engineers you want to bring in do not want to work inside the platform.
What can you keep, and what usually needs rebuilding?
A move is rarely a rewrite from nothing. Most of the hard work in an early product is the thinking, and that carries over.
| Usually kept | Often reworked | Usually rebuilt |
|---|---|---|
| What users need, learnt from real use | The data model, tidied and given proper constraints | Access rules, written and tested properly |
| The screens and flows people already know | Front-end code exported from an AI builder | Anything that handles payments or keys |
| The data itself, migrated and checked | Integrations with outside services | Logic locked inside a visual platform |
| The brand, copy and content | Background jobs and scheduled tasks | Sign-in and account recovery |
With an AI app builder, more can often be kept, because the code is real. The usual work is targeted: tighter access rules, keys moved to the server, limits added, flows hardened and tests written. With a visual platform, the logic usually has to be rebuilt, but the product design and the data move across.
If a rebuild is the honest answer, a good partner should say so and price it, rather than patching something that will keep breaking.
Why does security change the decision?
Apps built quickly with AI tools tend to work on the happy path and fail on the paths nobody tried. The common gaps are the same across tools: row-level access rules missing or too broad, secret keys shipped to the browser, no rate limits, weak account recovery, and customer data sent to AI providers without anyone checking what they keep.
None of this means the tools are bad. It means the output needs a review before real customers rely on it. For many founders, a security review is the right step before deciding whether to move at all: it tells you whether the current code can be made safe with targeted fixes, or whether the gaps are deep enough to justify a rebuild.
We cover the common gaps in how to make an AI-built app safe before launch, and the most frequent one, database access rules, in how to check Supabase row-level security. Our security review for AI-built apps finds, fixes and retests them in 1 to 3 weeks. If a customer has asked for a penetration test, read penetration test or security review first.
What does a move cost, and how long does it take?
The honest answer depends on what you are moving from, and how much of it can be kept.
Hardening an app built with an AI tool, where the code is real and mostly sound, is usually the smallest job: a security review with targeted fixes, in 1 to 3 weeks. Moving the logic out of a visual platform onto a custom build is larger, because the behaviour has to be rebuilt even though the design and the data carry across. A first product typically takes 1 to 8 weeks, and larger platforms are delivered in phases of 6 to 8 weeks, each priced before it starts.
Four things move the price more than anything else:
- How much logic lives inside the platform. Workflows built from visual blocks have to be rewritten; exported code may only need hardening.
- How messy the data is. Duplicated records, free-text fields doing the job of proper ones and missing relationships all need cleaning before migration.
- How many outside services are connected. Each integration has to be rebuilt or re-pointed and tested.
- What must keep running during the move. A product with paying customers needs a careful switch-over, with old and new running side by side.
Whatever the size, the price should come before the work. Ask for a written plan, a fixed price and the risks before anything starts, and make sure any change to scope is re-scoped and re-priced in writing.
What should you ask before you hand the app to someone else?
- Will the code, the database and the hosting be in our accounts from the first day?
- Will you review what exists and tell us plainly what is worth keeping, before quoting?
- How will you prove the migrated data matches the old app?
- Which flows will you harden first, and how will you test the access rules?
- How long will old and new run side by side, and who decides when to switch?
- What happens if a defect turns up after launch?
How does a migration actually run?
A careful move keeps the product live and the users unaware that anything changed. The steps we follow:
- Review what exists. Read the code or the platform's logic, the data and the integrations, and write down what is worth keeping.
- Agree the target. A written plan, a fixed price and the risks, approved before any work starts.
- Set up your accounts. Repositories, hosting and database in your name from the first commit.
- Move the data model first. Recreate it with proper constraints and access rules, with tests for the rules that must never break.
- Rebuild or harden each flow. Starting with sign-in, payments and anything touching personal data.
- Migrate the data and check it. Counts, totals and sample records compared between old and new.
- Switch over, then retire the old app. Once the new version has run alongside and the numbers agree.
How Rare Agentics can help
If your app was built with Lovable, Bolt, Cursor, Replit, v0 or a similar tool, start with our security review for AI-built apps. It is quoted to scope, and tells you plainly whether targeted fixes are enough. If it is time to move to a custom build, our bespoke software builds take you there at a fixed price agreed in writing, with the code in your own accounts. Tell us what you have built, and within two working days you get a first view.