Articles

Implementation

Bolt vs. Lovable vs. Reviewed Development: Test Portability Before Choosing an AI Builder

A source-code export is useful, but portability depends on whether the application’s data, identities, configuration, integrations and deployment can also be recovered.

November 11, 202614 min read
A hand moves one wooden cube beside a structure assembled from matching cubes.
Photo by Imagine Buddy on Unsplash

A working prototype is not yet a portable application

A technical lead needs to choose how to deliver a small employee approvals application. Staff sign in, submit requests, attach files and receive notifications. Managers have different approval permissions, and the organization has decided how much downtime and data loss it can accept.

The prototype looks complete in a browser. Its source can also be downloaded or synchronized to a repository. That still leaves a practical question: if the original builder path becomes unavailable or unsuitable, can the organization recover the complete application?

Editable source is only one part of that answer. The running application may also depend on database records, uploaded files, authentication settings, authorization rules, server functions, secrets, external service accounts and deployment configuration. A repository that omits or merely points to those components does not prove that they can be reconstructed.

For this decision, operational portability means the independently verifiable ability to recover and operate the application’s code, data, identities, configuration, integrations and deployment state within its declared recovery boundary. It does not require eliminating every managed service. It does require knowing which services remain, who controls them and how operation would be restored.

Bolt, Lovable and conventional reviewed development should therefore face the same drill. The official documentation used here reflects a 2026 product context. That matters particularly for Lovable, whose external deployment documentation distinguishes older React and Vite applications from newer TanStack Start applications created from May 13, 2026. Bolt’s documentation also notes an April 2026 project-code storage transition affecting the availability of its StackBlitz opening route. These documented capabilities establish what can be attempted, not that a particular application has completed the move.

Define the application and its recovery boundary

Start with one representative application, not an abstract platform comparison. For the approvals application, define:

  • employees and approvers who use it;

  • roles and authorization decisions;

  • approval records and audit-relevant fields;

  • uploaded documents and their storage location;

  • employee sign-in and any external identity provider;

  • notification services, webhooks and scheduled work;

  • browser, server and database functions required at runtime;

  • acceptable downtime and maximum acceptable data loss.

You also need authorized access to inspect the builder project, repository, database, identity settings, configuration names and deployment process. Do not copy secret values into the assessment. Record each secret’s name, purpose, owner and intended destination instead.

The reviewed-development reference must implement the same application and operating boundary. A conventional repository backed by managed hosting, GitHub and Supabase is not inherently portable. Its accessibility, configuration and restore path still need to be tested. GitHub, for example, supports several authentication methods, while credentials and tokens can expire or be revoked, so repository ownership must include a sustainable access and recovery arrangement (GitHub authentication documentation).

This decision exercise is not a fresh application build, a complete production migration, a security audit, a pricing comparison or a performance benchmark. It establishes whether the proposed ownership and recovery model is credible enough for choosing an approach.

Prepare the portability evidence

  • Describe the application workflow, users, required roles and approval decisions.

  • Record acceptable downtime and the maximum acceptable data loss.

  • Confirm authorized access to the builder project and its relevant settings.

  • Confirm repository ownership, clone access, history visibility and review permissions.

  • Collect dependency manifests, lockfiles, build commands and runtime requirements.

  • Locate schema definitions, ordered migrations and database-function records.

  • Identify a safe data-export or restore route without copying production data unnecessarily.

  • Inventory storage buckets, uploaded files and their access policies.

  • Record authentication providers, authorization rules and permitted redirect URLs.

  • List environment-variable and secret names, owners and destinations without recording secret values.

  • Record ownership of integrations, webhooks, domains, deployment accounts and pipelines.

  • Locate rollback records and name an owner for every component that would be operated independently.

Choose how much independence the application needs

There are two legitimate targets. The first moves code review or deployment into organization-controlled accounts while retaining selected backend services. The second requires the complete operating stack to be reconstructable elsewhere.

Choose before scoring because the pass conditions differ. If the approvals application is allowed to retain its current managed database, continuing to use that database can pass, provided the organization controls the relevant account and has an acceptable recovery route. It would fail a full-stack reconstruction target if the database could not be moved or recreated.

The full-stack route also creates more work. Lovable’s migration guidance makes that tradeoff explicit: moving a backend requires the operator to assume responsibility for areas such as availability, backups, authentication-provider configuration, environment settings and incident response (official deployment guide). Greater independence is useful only when the organization is prepared to operate what it takes over.

Choose the recovery target before scoring

Keep selected managed services

Move development or deployment under independent control while retaining named backend services. Those services, their accounts and their recovery arrangements remain inside the application’s declared recovery boundary.

Reconstruct the complete operating stack

Recreate code, persistent state, identities, configuration, integrations and deployment under independently controlled accounts. This produces stronger portability evidence but transfers more maintenance and recovery responsibility to the organization.

Run one drill with one scoring rule

Apply this procedure separately to Bolt, Lovable and the reviewed-development reference:

  1. Freeze a representative state. Identify a specific source revision, schema state, small set of test records, test identities and files. Avoid using uncontrolled live changes as the baseline.

  2. Collect controlled artifacts. Gather the source, history, build records, migration definitions, configuration names, export or restore material and ownership records identified earlier.

  3. Reconstruct through an independent path. Use a repository, deployment account and destination configuration controlled by the organization. Retain managed services only when the chosen recovery target permits them.

  4. Run observable workflow checks. Exercise sign-in, role enforcement, approval reads and writes, files, notifications, server behavior and relevant logs.

  5. Exercise recovery. Check code, deployment, schema and data recovery separately, then record what happens if a retained dependency is unavailable.

  6. Record evidence and ownership. Identify what passed, what remains tied to a provider and who maintains each independently operated component.

Use these ten scorecard rows:

  1. Export completeness

  2. Repository control

  3. Managed dependencies

  4. Database migration

  5. Identity configuration

  6. Secrets and runtime configuration

  7. Testability

  8. Deployment reconstruction

  9. Rollback and restoration

  10. Long-term ownership

Score every row with the same labels:

  • Pass: The requirement for the selected recovery target is documented and demonstrated by recorded execution with controlled artifacts.

  • Partial: A usable route exists, but one or more declared components remain dependent, manual or incompletely verified.

  • Fail: The required component cannot be obtained, reconstructed or operated within the declared boundary.

  • Unknown: Neither the available documentation nor recorded execution establishes the answer.

Keep the evidence state beside the score: documented capability, hypothetical procedure or recorded execution. A vendor document can support the first state. A planned sequence belongs in the second. Only an execution record with observable checks supports the third.

Do not hide a critical failure behind an average. If employee authentication, approval data or deployment reconstruction fails a mandatory recovery requirement, the application-level result cannot pass even if most other rows do.

Prove the code can leave and reviewed development can continue

Inspect the exported source as a development handover. It should provide or identify the application code, dependency manifests, lockfiles, generated assets needed at build time, migrations, server-side code, build instructions and required configuration names. Then verify that an authorized developer can clone or extract it, install dependencies, build it, run relevant tests and submit a reviewed change outside the original builder interface.

Bolt documents a project download as a ZIP that can be opened locally, with Node.js and the project’s installation and development commands used to run it (Bolt project files). Bolt also documents GitHub synchronization behavior and a reauthorization route when synchronization fails (Bolt integration troubleshooting). These are useful source-access capabilities, but the drill must still inspect what the particular export contains and whether its external build succeeds.

Lovable documents two-way synchronization with a repository owned by the user on GitHub, GitLab or Bitbucket. It synchronizes one branch at a time, distinguishes repository permissions from Lovable project permissions and supports local IDE work. Its documentation also states that the repository does not contain database records or secrets (Lovable Git sync). Branch controls therefore need deliberate handling. If every change to the main branch requires review, keep builder changes on a separate branch and merge them through the established review process.

For reviewed development, inspect the repository rather than assuming it is complete. Confirm that the organization owns it, authorized maintainers can access its full history, branch protections match the review process and build instructions do not depend on one developer’s machine or undocumented account.

Trace the database, files and managed backend services

Follow persistent state independently of the source tree. Trace:

  • schemas and ordered migrations;

  • table contents and user records;

  • uploaded files and storage policies;

  • database functions, triggers and row-level authorization policies;

  • edge or server functions;

  • scheduled jobs and managed connectors.

A schema copy is not a data export. A database backup is also not automatically a backup of stored files.

Bolt documents that duplicating a project with a Bolt database can copy structure without the data. Its project documentation also describes different behavior for Bolt databases and connected Supabase projects during duplication, transfer and deletion (Bolt project files). Those details show why a reader must inspect the actual backend choice. Complete migration of a native Bolt database to an independently operated production backend should remain Unknown until official documentation or a recorded drill establishes the required route.

Lovable documents a more explicit separation. Its repository can contain migration and function code, while database records, storage files, secrets, sign-in settings and managed connector credentials move through separate paths. Lovable’s database export contains database structure and data, including user accounts and password hashes, but excludes storage files, function code, secrets, sign-in-provider settings and project API keys (Lovable database backups). Its external deployment guide assigns separate migration work to storage files, functions, jobs, connectors and AI calls.

Apply the same standard to reviewed development. If the reference uses Supabase, for example, Supabase states that database backups do not include objects stored through its Storage API, only their database metadata (Supabase backup documentation). The test therefore needs both a database restore route and a separate route for stored objects.

Recreate identities, permissions, configuration and integrations

Create a destination-side record for every runtime dependency without recording sensitive values. Include:

  • sign-in providers and permitted redirect URLs;

  • employee and approver role mappings;

  • authorization or row-level security rules;

  • environment-variable names and intended environments;

  • secret names, owners and rotation responsibility;

  • webhook validation method;

  • external API accounts and notification services;

  • domains, certificates and DNS ownership;

  • builder-managed connectors that may need replacement.

For each item, ask whether it can be recreated from records controlled by the organization. A secret name in source code does not prove access to the credential. A copied authorization policy does not prove it has been enabled or behaves correctly in the destination.

Bolt’s troubleshooting documentation confirms that server functions can depend on separately stored secrets and that secret access in shared projects is limited by project role. It also describes authentication, CORS and webhook-validation settings that may affect external integrations (Bolt integration troubleshooting). These settings belong in the reconstruction record even when the source function itself is present.

Lovable states that secrets remain outside the repository and that credentials behind some managed connectors cannot be copied out. Its migration guidance requires authentication providers, redirects, secrets and external services to be configured again. When user accounts are restored into a new Supabase project, existing sessions do not carry over and users need to sign in again (Lovable external deployment guide).

Mark a managed connector Partial if retaining it is allowed and its account ownership is acceptable. Mark it Fail for a full-stack target if equivalent operation is mandatory but no replacement can be reconstructed. Use Unknown when the route has not been established.

Build, test and deploy through an independently controlled path

A local screen that opens successfully is not enough. Build from the controlled repository or export, supply configuration at the destination and deploy through an account the organization controls.

For the approvals application, check these observable behaviors:

  • an employee can sign in and sign out;

  • an approver can see permitted requests but not unauthorized records;

  • test records can be created, read and updated;

  • a test file can be uploaded and retrieved;

  • the notification integration receives the expected safe test event;

  • nested routes open directly and survive a refresh;

  • required server functions execute;

  • deployment and runtime logs are available to the operating owner.

Lovable’s documented hosting requirement depends on the project generation. Older React and Vite applications produce static output, while newer TanStack Start applications require hosting that runs their server output, server functions and API routes. A static-only deployment can therefore render part of an application while leaving server behavior unavailable (Lovable external deployment guide).

For Bolt and reviewed development, derive the destination requirements from the exported project rather than assuming a hosting model. Record the source revision, configuration revision, destination and check results. Until those checks have actually run, score the route as a hypothetical procedure rather than recorded execution.

Test rollback and the loss of a managed dependency

Treat recovery as several operations, not one button:

  • revert application code;

  • restore or reverse a schema change;

  • return a deployment to a known release;

  • restore data to an acceptable point;

  • recover separately stored files;

  • restore access to repository, deployment and service accounts.

Bolt explicitly states that restoring an earlier project version does not change the current Bolt or Supabase database. Its version history, local download and GitHub routes can recover project files, but database recovery remains a separate concern (Bolt backups and version history). A code rollback can therefore produce an application version that no longer matches the current schema unless the database change has its own recovery plan.

Lovable’s database backups cover the database rather than storage files. Restoring a database can also revert the schema and create a mismatch with newer application code. The documented restore is destructive to data changed after the selected backup, so code, database and storage recovery must be coordinated rather than treated as one operation (Lovable database backups).

The drill should also ask what happens when repository sync fails, the deployment account is inaccessible, a secret is absent, an identity provider rejects a redirect or a managed connector cannot be moved. The minimum recovery record is an off-platform inventory of controlled accounts and artifacts, a short restoration sequence and a named maintainer for each component. For related operational design, see where AI implementation usually breaks.

Choose Bolt, Lovable or reviewed development from the completed evidence

There is no universal winner. Choose the approach whose completed scorecard meets the declared recovery boundary and whose operating burden the organization can sustain.

Bolt can fit when fast builder-led development is useful and its documented download, repository and integration boundaries satisfy the application’s selected target. If the application relies on a native backend whose complete migration route is not established, leave the relevant database and full-stack reconstruction rows Unknown rather than treating the source download as proof.

Lovable can fit when the team values builder-led development but also needs documented repository synchronization, external deployment and backend migration paths. Its official documentation provides explicit separation among code, database exports, storage files, identities, secrets, functions and connectors. That makes the work visible, but it does not remove the work. A full move transfers more deployment, backend, security and maintenance responsibility to the organization.

Reviewed development can fit when direct repository control, established review gates and architecture choice justify greater setup and maintenance. It should not receive an automatic portability pass. Its deployment pipeline, database restore, storage recovery, identity configuration and account access must survive the same drill.

The simpler option is often to retain selected managed services. That reduces reconstruction effort and can be a sound choice when those services meet the recovery requirement, the organization controls their accounts and the remaining dependence is recorded honestly.

Use the mandatory rows to make the final decision. For the approvals application, a route that cannot recover employee access or approval records is unsuitable even if its development experience is convenient. Conversely, requiring a complete backend replacement may add unnecessary work if the organization only needs independently reviewed code and deployment while deliberately retaining a managed database.

For context on MadSar’s implementation offer, see Workflow & Agent Implementation.

Take one portability snapshot before choosing

Choose one existing prototype or proposed architecture, such as the approvals application, and record where its code, records, identities, files, secrets, integrations and deployment settings live. Mark each item Controlled, Reconstructable or Unknown.

The result should fit on one page. The first Unknown attached to a mandatory recovery requirement is the dependency to test next.

Questions and answers

Does downloading the source code make an AI-built application portable?

Not by itself. The download must contain enough code and build information to continue development, while data, files, identities, secrets, integrations and deployment state need separate recovery paths.

Is reviewed development automatically more portable than Bolt or Lovable?

No. A conventional repository can still depend on inaccessible accounts, undocumented configuration or untested backups. Apply the same reconstruction and recovery drill to every approach.

Should every application be able to leave all managed services?

Not necessarily. Keeping selected managed services can be a valid choice when the organization controls the accounts and accepts those services as part of its recovery boundary.