# What you actually own when you leave Replit

> The code you built and the data in your database are yours, and both move with you. What does not move is the platform: the agent, the one click publishing, the managed environment and the address your app currently lives at. Owning the code and the database is what makes any future move cheap, because it turns leaving into a logistics problem rather than a rebuild.

Source: https://neurobird.com/replit-migration/export-your-app/ | Neurobird | Updated 2026-08-28

This page is about ownership, not procedure. It is worth being precise, because the fear that keeps people on a platform they have outgrown is usually a vague sense that the app somehow belongs to the platform. Mostly it does not. What belongs to the platform is the convenience, and convenience is the cheap part to replace.

## Do I own the code I built on Replit?

      Yes. The code is yours, the data in your database is yours, and the files your users
      uploaded are yours. That is the important half of the answer and it is worth sitting with,
      because it means the app is not trapped anywhere. An app is, in the end, a body of code, a
      database, some files, some settings and a name people type into a browser. Every one of
      those is a thing you can hold.
      What you do not own is the machinery around them. The agent that writes the code, the
      environment it runs in, the publishing that puts it on the internet in one click, the
      address it currently answers on. Those are rented, and they stop the day you stop paying.
      That is not a trick or a trap. It is simply what a platform is.

      
## What actually moves when an app leaves a platform?

      Everything that carries your work or your customers' work moves. Everything that carries
      the platform's convenience does not. Sorting your app into those two columns is the single
      most clarifying thing you can do before making any decision about where it lives.
      | Part of your app | Yours or rented | What that means in practice || The code | Yours | It runs anywhere that can run that kind of app || The database contents | Yours | Every account, order and record moves intact || Uploaded files | Yours | Images and documents come along with the rest || Your domain name | Yours | Registered to you, points wherever you tell it to || The AI agent | Rented | Stays behind. Replaceable, but not free || One click publishing | Rented | Replaced by a normal server setup, done once || The platform address | Rented | Any link pointing at it needs to point somewhere else || Platform specific conveniences | Rented | The part that needs rebuilding, and the part worth checking early |

      
## What does not transfer, and does it matter?

      The things that do not transfer are conveniences, and how much they matter depends on
      how deeply the app leans on them. An app that keeps its data in the platform's built in
      database and uses its built in login is leaning hard. One that mostly stands on its own is
      barely leaning at all. Neither is a problem, but they are different amounts of work, which
      is why I quote after reading an app rather than before.
      This is also the honest reason a straightforward app is a fixed five hundred dollars and
      an app with background jobs, file uploads, payments or several services talking to each
      other starts at one thousand. The variable is not size. It is how many platform
      conveniences have to be replaced with things you own.

      
## What is vendor lock-in, actually?

      Lock-in is not someone holding your code hostage. It is the cost of leaving being high
      enough that you keep choosing to stay after staying stopped making sense. That cost is built
      from small things: data in a shape only this platform uses, a login that only exists here,
      and a quiet uncertainty about whether the thing would even start up elsewhere. None are
      dramatic alone. Together they are why people keep paying a bill that keeps growing, and it
      does grow, because the cost of changing an app is tied to its size:
      
> Effort-Based pricing can end up being more expensive over the lifetime of a project, and median statistics do not capture outlier datapoints well.
> Replit, Effort-Based Pricing Recap, source

      Which produces the specific trap worth naming: the longer you stay, the more the app is
      worth to you, and the more expensive it becomes to change. Lock-in and cost growth push in
      the same direction. That is why the sensible time to understand your ownership position is
      before you need it.

      
## Why does owning the database matter more than owning the code?

      Because code can be rewritten and data cannot. If you lost your codebase tomorrow, the
      app could be rebuilt, painfully and expensively, but it could be rebuilt. If you lost your
      customer records, orders and accounts, nothing brings them back. Everything anyone actually
      cares about in your app lives in the database.
      So when I talk about handing over an app, the part I care most about is that the data
      ends up somewhere you control, with backups that run without anyone remembering to run
      them, and that you can prove the backups exist before you ever need one. A backup nobody
      has tested is a belief, not a backup.

      
## What does owning your app get you?

      It turns any future move into logistics instead of a rebuild. That is the whole benefit,
      and it is bigger than it sounds. When the code and the data are yours and sit on a machine
      rented in your name, a pricing announcement from any vendor becomes an inconvenience rather
      than an emergency. You are never negotiating from a position where leaving is unthinkable.
      It also changes the shape of the bill. A rented machine is a flat monthly number attached
      to hardware rather than to activity, and it stays the same in a busy month and a quiet one.
      Replit publishes a per request range instead:
      
> Simpler requests may cost as little as $0.06 and more involved requests will usually cost more than $0.25, sometimes resulting in charges of multiple dollars depending on the size of the work.
> Replit, Effort-Based Pricing Recap, source

      
**DigitalOcean lists Droplets from $4.00 a month and Amazon Lightsail from $5 a month, both flat rates that do not change as a project grows. DigitalOcean Droplet pricing**

      The flat number is not automatically better. It is better for a finished app that is
      being used, and worse for an app still being built, which needs the agent that comes with
      the platform. Ownership is not an argument for leaving. It is an argument for knowing what
      leaving would cost, so the decision stays yours.

      
## Do I need to be technical to own my app?

      No, and this is where people get talked out of ownership by people who like feeling
      technical. Owning a house does not require knowing how to lay bricks. What it requires is
      the keys, a record of where everything is, and someone to call. The same is true here: the
      accounts are in your name, the code and data are in your possession, and there is a plain
      English description of what you now have and where it sits.
      That handover guide is part of a migration for exactly this reason. An app you own but
      cannot describe is only half owned. Six months later, with no memory of any of it, you
      should still be able to say where your app lives and who else could pick it up.

## Questions

### Do I own the code I built on Replit?

Yes. The code you built, the contents of your database, the files your users uploaded and your domain name are yours and all of them move with you. What stays behind is the platform convenience: the AI agent, the managed environment, one click publishing and the platform address the app currently answers on.

### What does not transfer when you leave a platform?

The rented parts. The agent that writes your code, the environment it runs in, the one click publishing and any platform specific conveniences such as a built in login system all stay behind. How much that matters depends on how heavily the app relies on them, which is why a migration is priced after reading the app rather than before.

### What is vendor lock-in in practice?

Lock-in is the cost of leaving being high enough that you keep staying after staying stopped making sense. It is built from small things: data in a platform specific shape, a login that only exists there, and uncertainty about whether the app would start up elsewhere. Owning the code and the database is what keeps that cost low.

### Why does owning the database matter most?

Because code can be rebuilt and data cannot. Customer accounts, orders and records exist in one place only, so the measure of a real handover is that the data sits somewhere you control with backups that run automatically and have been proven to work.

### Do I need to be technical to own my own app?

No. Ownership means the accounts are in your name, the code and the data are in your possession, and there is a plain English record of what exists and where it sits. That is why a short handover guide is part of the work rather than an extra.

## Get a fixed price

Send the link to your app at https://neurobird.com/replit-migration/#start . You get a list of what it uses and a fixed migration price back within one business day.
