How a Replit app usually gets into trouble
With most tools the code is written in one place and run in another, so the founder learns early where things live. On Replit both happen in the same account, and the agent can create a database, store a key and start the app without you having to know where any of it went. That works well up to the day other people depend on it.
The trouble we see most often comes from that hidden layout. A change shows up in the workspace and customers do not see it. Customer records vanish or reset. Uploaded files are there in the morning and gone by the afternoon. People get signed out for no reason they can see. Each has an ordinary explanation, and the table pairs each with a question to answer.
Replit symptoms and the question each one raises
- What happens
- You changed something and customers still see the old version
- Common explanation
- The copy you edit and the published copy are separate, and the published one was not updated
- Question to answer
- When was the published app last updated, and from which state of the code?
- What happens
- Test records appear in front of customers, or customer records disappear
- Common explanation
- The building copy and the published copy share a database, or the agent changed tables while people were using them
- Question to answer
- Does each copy have its own database, and which one did the last change touch?
- What happens
- Uploaded images or files go missing
- Common explanation
- Files were saved into the app's own folder, which is often not kept when a published app restarts or is updated
- Question to answer
- Where exactly does an uploaded file get stored?
- What happens
- Everyone is signed out at random times
- Common explanation
- Sign-in sessions are held in the running app's memory and are lost when it restarts
- Question to answer
- Where are sessions stored, and what restarts the app?
- What happens
- The first visit after a quiet spell is very slow or times out
- Common explanation
- Depending on how it is published, the app may be stopped while idle and started again on demand
- Question to answer
- Is the app published in a way that keeps it running?
- What happens
- A feature using an outside service works for you and fails for customers
- Common explanation
- The key is stored for the workspace and not for the published app
- Question to answer
- Is every stored key present in both places?
| What happens | Common explanation | Question to answer |
|---|---|---|
| You changed something and customers still see the old version | The copy you edit and the published copy are separate, and the published one was not updated | When was the published app last updated, and from which state of the code? |
| Test records appear in front of customers, or customer records disappear | The building copy and the published copy share a database, or the agent changed tables while people were using them | Does each copy have its own database, and which one did the last change touch? |
| Uploaded images or files go missing | Files were saved into the app's own folder, which is often not kept when a published app restarts or is updated | Where exactly does an uploaded file get stored? |
| Everyone is signed out at random times | Sign-in sessions are held in the running app's memory and are lost when it restarts | Where are sessions stored, and what restarts the app? |
| The first visit after a quiet spell is very slow or times out | Depending on how it is published, the app may be stopped while idle and started again on demand | Is the app published in a way that keeps it running? |
| A feature using an outside service works for you and fails for customers | The key is stored for the workspace and not for the published app | Is every stored key present in both places? |
The copy you edit and the copy your customers use
Think of the project as two things. One is the workspace, where you and the agent make changes and press run to try them. The other is the published app at the address you gave your customers. Publishing takes a picture of the workspace at that moment. Later edits stay in the workspace until you publish again, which is why a fix can look finished to you and be invisible to everyone else.
This separation is useful once you know it is there, because it lets you try changes away from customers. Make it deliberate. Keep a short log with three columns: the date, what changed, and whether it has been published. Before telling a customer something is fixed, open the public address in a private browser window, signed in as an ordinary test user, and check it there. The run button in the workspace only shows you the workspace.
Where the keys and the customer data are kept
Keys for payment, email and AI services belong in the platform's secrets store, where they are kept out of the code. Open it and read down the names. Then ask the agent to list every place the code expects a secret, and compare the two lists. A name the code expects and the store lacks explains a feature that fails without a clear message. Check too that nothing secret was typed straight into a code file during an early session, since anyone you share the project with can read those files.
The database deserves more care, because it is the one part you cannot regenerate. Find out which database the published app reads and writes, whether the workspace uses the same one, and whether a backup exists that you know how to restore. An agent asked to add a field may alter or recreate a table to do it. On a database with only test rows that costs nothing. On the one holding your customers' records it can lose them. Before any request that changes how data is stored, say plainly in the request that existing records must be kept, and take an export first.
Restarts, uploads and other things that do not last
A running app is a program that can be stopped and started again at any time: when you publish an update, when it crashes, or when the platform moves or pauses it. Anything the program was only holding in memory is gone after a restart. Anything it wrote into its own folder may be gone too, depending on how the app is published. With one user who rarely leaves the page, you may never see a restart. With many users across a day, restarts land in the middle of somebody's work.
Three things are worth tracing. Uploaded files should go to storage built for files, with the database keeping a reference to each. Sign-in sessions should be kept in the database or a similar store, so a restart does not sign everyone out. Scheduled work, such as a reminder email sent every morning, needs something that runs it on time even if the app was asleep. Ask the agent how your app handles each of these and ask it to point to the code. Then test the first two directly: upload a file and sign in on the published app, publish a trivial update, and see whether the file and your session survived.
Uploads that vanished after every update
Staying on Replit or moving somewhere else
Founders often arrive assuming a serious product has to leave the platform it was built on. That is a decision to make on evidence. If the published app stays up, the data is backed up, and the running cost is one you understand, staying is reasonable. Moving makes sense when you need something the platform's way of running apps does not suit, when a developer you hire prefers to work elsewhere, or when the bills are hard to predict.
Whichever you choose, be able to leave. That takes four things, and all of them are worth having even if you stay: the code in a repository under your own account, an export of the database you have restored at least once somewhere else, a written list of every secret by name, and a note of anything in the code that relies on a feature only this platform provides. Ask the agent for that last list directly. A project with those four things can be moved in an orderly way, on a date you pick.
When your own checks are enough and when they are not
A fix that was never published, a key missing from one of two places, an app published in a mode that lets it sleep: you can settle these yourself with the table above, and no engineer is needed.
Get someone in when customer records have been lost or mixed, when you cannot say with confidence which database the live app is using, or when the app falls over as soon as more than a few people use it at once. Those need a person to read the code and the data together, and further agent sessions on a live database carry real risk. Our Diagnostic is a fixed-price written plan covering what is safe as it stands, what has to change before more users arrive, and whether staying or moving suits you better. The fee is credited to the build if you go ahead. Your Replit account, your code and your data stay with you.
Before the agent's next session
Write these down first. They are the facts that stop a routine change from reaching your customers' data by accident.
- The public address customers use, and the date the published app was last updated.
- Which database the published app uses, and whether the workspace shares it.
- A database export taken today, and where you saved it.
- The names of all stored secrets, checked against what the code expects.
- Where uploaded files and sign-in sessions are stored.
- A copy of the code in a repository under your own account.
We can steady your Replit app before more users arrive.
Tell us on a free consultation what your customers are running into and what you already know about where the app and its data live. We will say whether the fixes look small enough to do yourself. If you want us involved, we start by backing up what you have, and the app stays in your account throughout.
Book a free consultationOn the project call, we’ll discuss the problem, your existing tools and what TDAT should take off your hands. Then we can define the scope and next steps.
Or call (919) 289-1231
Questions before we start
Can a real business run on Replit?
It can, and some do. What matters is whether your particular app is published in a way that stays running, keeps its data and files in durable storage, and is backed up. Those are properties of how the app was set up, and the checks on this page tell you which ones you have.
Why did my data disappear on Replit?
The usual explanations are a change to the database structure that recreated a table, a building copy and a published copy pointed at the same database, or files saved inside the app's folder and replaced on the next update. Check your change log against the time the data went missing before asking the agent to repair anything.
Can I move my Replit app to other hosting?
Generally yes. The code is standard and can be copied to a repository, and the database can be exported. The work is in the details: secrets, file storage and anything written around platform-specific features. Restore the database export somewhere else once before you rely on it.
The Replit agent keeps saying it fixed the bug. Why is it still there?
Two common reasons. The fix is in the workspace and the published app was not updated, or the agent confirmed the change by reading its own code without running the journey as a signed-in customer. Test on the public address with a test account before accepting that a bug is closed.
How does TDAT work on an app that lives in my Replit account?
After a free consultation, you invite us to the project or share the repository, and we agree what we may touch. We work on a copy and leave the live database alone until a backup has been taken and restored. Nothing is moved off your account unless you decide it should be.