Take a v0 App to Production: The Work Under the Screen
v0 delivers the interface. Production is the auth, the data, and a deploy under that screen. A polished page is not a second user or a ledger.
By Muhammad Saif and Aashan Khan · Techtribe co-founders
v0's gift is the screen. You describe an interface. You get interface code that looks finished, and you can scaffold an app around it. People react to the screen, so the screen is what you remember, and what you demo, and what a stakeholder thinks you have already built. The stakeholder is reacting to the part that was always going to arrive first. Auth, the database, and a deploy on a cloud you control are not implied by a navbar.
The guide is take your v0 app to production. This article is when to stop generating pages and start putting a product under the page you already have. It is not the incident report. When a Replit or v0 app breaks after people depend on it, that piece is when a Replit or v0 app breaks in production. Read that one if you are already in the outage. Read this one if the screen is impressive and nothing underneath has been asked to hold a second user.
Bolt generates a full stack in the browser, so the Bolt article, take a Bolt app to production, spends its time separating real files from implied production. Replit already hosts the app, so take a Replit app to your cloud spends its time on the move off that host. v0's specific trap is different. The trap is believing the interface is the product.
The screen is a spec, not a launch
Treat the generated UI as a specification you can click. That is more valuable than a document, and it is less valuable than a system. Walk the happy path and write down what each control claims. "Save" claims a row will exist later. "Invite" claims a second person will have a different login. "Upgrade" claims money will change what the account can do. The claims are the scope. The pixels are how you found the claims.
If a control claims something the app cannot do, you have two honest choices. Remove the control before anyone important clicks it. Or build the thing it claims, as a scoped piece of work, with a server and a rule. Leaving the control in place because it looks complete is how a demo becomes a support ticket. A disabled control with a sentence is a better product than a button that writes nothing and smiles.
Do not restyle the product as the first response to this gap. A new design system on a screen that already communicates the job is a way to spend the calendar on taste. Design in your brand belongs in the build when a customer will compare the screen with the rest of your company. It does not include a rebrand as a substitute for a missing table. If the screen is ugly and the save is real, you can ship the ugly save. If the screen is beautiful and the save is a console log, you cannot.
What has to exist under the page
A user the server believes. Not a flag in local storage, not a hardcoded email that the demo used, not a check that runs only in the component. When a second person signs up, their session is theirs. When they are logged out, the request for the first person's data fails on the server. You prove this with two accounts before you send the link to anyone who is not you. The proof is the feature. The login form was the costume.
A schema you can migrate. The fields on the screen become columns or documents you can name, with a migration in the repo, not a shape that appeared because the component needed props. If v0 scaffolded a database, read it before you praise it. Generated schemas tend to match the screen one-to-one and miss the noun that matters: an account, a membership, a payment that is not the same thing as a user. Can you trust an AI-generated database migration is the caution on applying that scaffold to anything you cannot restore.
A core flow checked against a real record or a real payment. Clicking through seeded data is a review of the layout. Creating a row as a second user, seeing it, and failing to see someone else's row, is a review of the product. If money is on the screen, the processor event has to land in your database once. The article that debugs a missing webhook is Stripe webhook not triggering. The article that scopes a subscription onto a prototype that only demos checkout is add subscriptions to an AI prototype. Use the first if an endpoint is dead. Use the second if the button was never a ledger.
A deploy on your cloud, with a way back. The preview host is a fine place to look at padding. It is a poor place to be the only copy of a customer's data. Your repo holds the commit. Your account holds the database. You have rolled back once, on purpose, before the day you need to. Staging does not point at production data. Secrets are not in the client bundle, and any secret that was, even briefly, is revoked rather than reused.
That list is the capability list on the v0 build guide. It is also the list a prompt that says "add a backend" will pretend to finish. Pretend is the word. Open the network tab. See what the save button calls. If it calls nothing, you still have a screen.
What v0 is good for after the decision
v0 remains a fast way to try a layout. After the production path exists, a generated variant of a page can be a pull request. A person reads it. It does not merge because it compiled. It does not get to edit the session, the policies, or the webhook. The same boundary shows up for every generator. The Lovable wording is in hire a developer to fix a Lovable app: low-risk UI, reviewed, and the dangerous paths changed by someone who can explain the diff.
If your team will own the screen, they need one safe change they can ship without you. A label. A column that is not a secret. The handoff is an AI product your team can maintain. A v0 project only the original prompt can evolve is a picture you rent. Put the picture in the repo.
When the screen should be kept, and when the path should not
Keep the screen when the job is understandable without a narrator. A stranger can do the thing. The labels match the task. You are not attached to it merely because it took a weekend. Attachment is not a requirement. Legibility is.
Rebuild the path under it when every page reads every row, when "auth" is a redirect that a curl can skip, or when the data model is a single blob that means something different on each route. You can reuse the components and replace the loader. Reusing the loader because rewriting feels rude is how the leak survives the migration. Components are cheap. A query is a policy. Treat it as a policy.
Rebuild the whole flow when the screen's claims are not the product you actually sell. v0 will happily render a marketplace, a chat, and an admin in an afternoon because those are familiar pictures. If you sell one workflow, delete the other pictures before they acquire tables. A table created to fill a sidebar is a migration you will fear later. The repair or rewrite note is the general verdict. On a v0 app the rewrite is often narrower than founders fear, because so much of the repo is the view. Narrow is good. Do the narrow thing. Do not let a narrow thing stay narrow in the proposal and wide in the invoice.
The package that matches the gap under the screen
If the screen is the brief and you need one flow, one AI feature, and a URL, and almost nothing real exists underneath, that is a short build. You are not "taking v0 to production" in the sense of hardening a large app. You are building the small product the screen described. Say that on the call. The short boundary is in an LLM MVP in two to four weeks. A scaffold that implies billing, teams, and three tools does not force those into a short engagement.
If users will depend on the app, the work is longer: design in your brand where the audience requires it, auth, billing hooks, a few integrations, your cloud, your repo, and the checks around a model if a model is actually in the path. Many v0 apps have a chat panel that was a component, not a product. Decide whether the chat is the feature or a decoration. A decoration should be deleted. A feature should be scoped as a feature, with citations and a refusal if it is document chat, which is chat over your documents, not a textarea with a glow.
Another integration, a second product, or a quarter of follow-on work is not a quiet addition. It is a separate yes, or a team that stays. When to hire a dedicated AI team applies when the screen was only the first page of a roadmap. A roadmap is allowed. It is not allowed to disguise itself as "just hook up the backend on the v0."
The gap under the screen is what we look at on the call. The tool does not decide the scope. Bring the screen and we will say what has to be built before anyone should call it launched.
A cutover that does not need every page
Freeze the screen you are willing to mean. Deploy the new path beside it. Prove one job with a second account. Only then point people at it. Pages you have not rebuilt stay out of the navigation. A cutover that waits until the settings page, the blog, and the empty marketing site are also perfect is a cutover that never happens, while the preview keeps collecting real emails in a database you do not control.
If the preview has already collected real records, export them, count them, and rehearse the load. Do not ask those people to register again unless you have decided the old rows were samples. Samples should be thrown away on purpose, in writing, so nobody "helps" by importing them into production later.
Keep the preview up until the new path has done the job once for someone who is not the builder. Then turn the preview's writes off. Two writers, the scaffold and the new app, will diverge by Friday. Divergence is a support problem you created to avoid a decision.
What we will not do with a v0 export
We will not spend the first week arguing about a component library when the save button has no server. We will not add a model because the hero said "AI." We will not treat a generated README as a security review. We will not deploy the scaffold onto production data to "see how it feels."
We will say if the screen is enough of a spec to build, and if it is not. A screen that contradicts itself, three ways to create the same object, no way to finish the job, is a brief that needs an edit before it needs a database. That edit can happen on the call. It does not need a six-week discovery.
What to bring
The v0 project and the repo if you exported one. The one flow a user must finish. A list of every control that implies a save, a payment, or a second person. Any key that has been in the browser. If a model is on the page, five questions it must answer from your data and two it must refuse. If you do not have the five, the model is still a decoration. Say so, and we will not treat the decoration as the feature.
Bring the audience: you and an investor, or a customer who will type a credit card. Those are different packages. The screen can be identical. The work under it is not.
If this is your app, send the repo.
A 30-minute scope call. We read what is live, name what is dangerous, and quote a fixed scope.
How Techtribe puts production under a v0 screen
We keep the interface that already explains the job. We replace or build the session, the data rule, and the deploy underneath it. Two accounts have to fail at seeing each other's rows. Secrets live on the server, and any secret that shipped to the browser is revoked. The core flow is checked against a real record. Pages that are only pictures stay out of the navigation until they are real.
A screen that is only a brief, with one flow to build, can stay a short build. A product a customer will depend on is a longer fixed scope. Continuing pages are a team that stays. We say which, on the call, after we have seen the screen. The guide is v0 to production. If you are already broken in front of users, start with when a v0 app breaks in production. The service page is AI MVP development.
The scope call is 30 minutes with a founder. Bring the screen and the one job it claims a user can finish. That is the meeting. The article is the preparation for it.
Questions
Is a finished v0 screen a finished product?
No. v0 generates the interface from a prompt, and it can scaffold the app around that interface. The screen is the part that arrives looking done. Auth, data, and a deploy you can undo are still the work under the screen.
Should we throw the v0 UI away and start the design over?
Keep the screen if a user can finish the job on it. Rebuild the path underneath when the data model or the auth cannot be trusted. A new visual design does not fix a query that returns every row.
How is this different from a v0 app that breaks in production?
The break article is what fails after real use: a business rule, a fix that disturbs a working path. This article is the decision to put auth, data, and your cloud under the screen before you call it launched.
How do we decide what belongs under the screen?
Book the scope call and bring the screen. A small repair under an otherwise sound interface stays a repair. The usual customer-facing move is auth, your cloud, and the core flow checked against a real record. We say which one after we have seen what the buttons claim.