Skip to content

Guides

Move a Lovable, Bolt or Replit app to your own domain

Keep the app you already built, bring its code to Tofu and connect a domain you own. The code, the saved data and the domain are three separate things to move.

Updated

The short answer

Export or sync the app's code to GitHub, import that repository into Tofu, set up the services the app needs and publish it. Once the app works at its Tofu address, connect your domain from the app's Domains page and add the DNS records Tofu shows.

You do not have to move hosts just to use your own domain. If your current platform offers the domain connection you need, keeping the app there may be simpler. This guide is for choosing Tofu to manage the app's hosting and, where needed, its database and sign-in.

Get the code from the tool you used

  • Lovable. Connect the project to GitHub from Project → GitHub in the project menu. Lovable creates a repository and syncs the project's code. Check the current branch and sync status before importing it into Tofu. See Lovable's GitHub guide.
  • Bolt. Use the GitHub icon to connect your account and create a repository for the project. Wait until Bolt reports that the changes are synced. See Bolt's GitHub guide.
  • Replit. Open the Git tool in the project editor, connect GitHub and push the app's code to the repository. Replit's version-control guide explains its Git tools.

Export controls depend on the tool and your workspace permissions. The repository should contain the complete app, including its dependency list and build setup. Keep private keys and .env files out of it. If you already have the app as a local folder, a coding agent can send that folder to Tofu instead.

Step by step

  1. Record what the working app depends on

    Before changing hosting, list its database, sign-in service, uploaded files, email and payments. Keep a copy of the code and arrange any data export you need. A GitHub repository normally holds code, not the records and accounts stored by those services. Keep the original app available while you test the move.

  2. Import the repository into Tofu

    Start a new app in the Tofu dashboard and choose the GitHub import. Connect GitHub if the repository is private, choose the repository and branch, and select the folder containing the app if it is below the repository's root. Tofu detects the app type. A local-folder alternative is on the agent setup page.

  3. Reconnect the app’s services

    Save private settings yourself on the app's Keys & settings page. If you keep an external database or sign-in service, it must accept the new app address and remain paid for and available. If you choose a Tofu-managed database, approve creating it and arrange the separate transfer of tables, records, accounts and files. The app's code must use its new connection. Database and Sign-in describe the setup Tofu supplies.

  4. Publish and check the Tofu address

    Put the app online and wait for Tofu's result. A build error needs a code or settings fix before it can go live. At the published address, test login, a saved record and the app's main action. Check private data with another account. Confirm any payment or email callbacks before moving visitors.

  5. Connect the domain you own

    On a plan that includes a custom domain, open Domains for the app and enter the name. Tofu provides an ownership TXT record and the routing records that send visitors to it. On Cloudflare, where the approval is offered, you can let Tofu add the connection's records. Otherwise, add the exact records at the company that manages your DNS. Change conflicting website records; keep unrelated email records.

  6. Wait for the connection, then check the new address

    Use the Domains page to check progress. It shows whether ownership, routing or the HTTPS certificate is still being prepared. On shared static hosting, connect a name below the root, such as www.example.com, and forward the root at your registrar. On other hosting, the root and its www can redirect to one another; the companion name's DNS record still needs setting. Once connected, test sign-in and the app's main action again on the custom address before retiring the old hosting.

What carries over, and what needs setup

Part of the appCarries overNeeds separate setup
Pages and app logicSource files and assets included in the repository.Build settings or platform-specific code that the new host cannot run as written.
Database and filesTable definitions or migration files committed with the app.Live records and uploaded files. A new managed database starts separately from the old one.
People and sign-inThe app’s sign-in screens and integration code.The auth service, return addresses and any account migration. Importing code creates no user accounts.
Email and paymentsIntegration code, where included.Private settings, event destinations and service connections for the new address.
Your domainYour ownership of the name stays at your registrar.DNS routing and HTTPS for the new host. The old app’s deployment history stays with the old host.

What Tofu does not do

  • Migrate the old platform’s backend by importing code. A source import does not copy a hosted database, user accounts, file storage or private settings. Plan those moves separately, or keep the original services connected where they support it.

  • Make platform-specific services portable. An app tied to its builder’s auth, database SDK or background jobs may need code changes. Tofu hosts web apps that answer requests, not a continuously running worker or scheduler.

  • Move the domain registration. Connecting the name changes where it sends visitors. Buying, renewing and transferring the name remain with your registrar, and the domain’s price is separate from hosting.

  • Promise an instant change for every visitor. DNS caches can keep an old answer for a while. Keep the previous app available during the move and use the connection status instead of assuming a saved record has reached everyone.

Questions

Can the repository stay private?

Yes. Connect GitHub in the Tofu dashboard and grant access to that repository. You do not need to publish the source code to use the authenticated import.

Can the existing database stay where it is?

If the service allows the new host to connect, the app can keep using it with the right settings. You remain responsible for that service. Tofu's managed sign-in setup applies to databases Tofu creates, not your external Supabase project or another login provider.

Can updates still come from the original builder?

If the builder continues syncing to the same GitHub branch, Tofu's automatic updates can follow that branch. Turn them on in the Source card on Versions. A manual upload or a version published from the Tofu builder pauses that connection. See automatic updates.

Does the Free plan include a domain?

The pricing page shows the current Free-plan allowance; the Domains page checks it for your app. The name itself is bought separately. Shared static hosting uses a www or another subdomain, with the root forwarded at your registrar.

Does adding a domain change sign-in automatically?

Tofu's Google sign-in entry point accepts a custom address recorded and connected to that app. An external auth provider may need its return addresses updated separately. Sign-in email settings can still use the app's Tofu address, so test the complete journey from the custom domain.