It ran perfectly inside Bolt's browser preview. You deployed it to Netlify, sent the link to your investors, and it immediately threw a white screen. Or it worked for your test account but broke the moment a real user signed up. Or every new prompt is making things worse, and you are starting to think the AI is trolling you.
Preview and production can differ in runtime, configuration and service access. A failed deployment is not proof that the model exceeded a context limit. Read the first error and compare the environment before making more changes.
Bolt preview not working? Start here
If the preview pane is blank, spinning, or showing "Something went wrong" or "Sorry, an unknown error occurred", work through these before touching your code. The preview is a full dev server running inside your browser tab, and most preview failures are environment problems, not app problems.
- Read the terminal, not the preview. The real error lives in Bolt's terminal and console pane. A blank preview almost always means the dev server crashed on startup. Copy the exact error text into the chat and ask Bolt to fix that specific error, not "the preview is broken".
- Check your browser, not just your project. Bolt's in-browser environment needs service workers and modern browser features. Ad blockers, privacy shields, strict Safari settings and private windows all break it. Try a normal Chrome window with extensions off before assuming your app is gone.
- Reload, then fork. A hard reload restarts the environment. If the project still will not boot, duplicate the project: a fresh container clears corrupted state without losing your code.
- Preview fine, deploy broken? That is a different failure: environment variables and service credentials that exist inside Bolt but were never added to Netlify or wherever you deployed. The diagnosis table below covers it.
Repeated preview failures may involve runtime resources, browser support or project code. Use Bolt's current troubleshooting guidance and the terminal error to isolate the cause.
Diagnose it: six symptoms, six causes
Use this table to identify possible causes and useful checks. Symptoms can have more than one cause; confirm the diagnosis with logs and a reproducible example.
| Symptom | Possible cause to investigate | Can you fix it yourself? |
|---|---|---|
| Works in Bolt preview, breaks on Netlify or Vercel | Possible cause: Bolt uses WebContainers, a browser-based development runtime. Compare runtime, configuration and service access with the destination deployment; use the actual build or runtime error to identify the difference. | Sometimes. Checking that your environment variables are set in the Netlify dashboard is a good first step. Server-side runtime mismatches need an engineer. |
| Breaks the moment a second user signs up | Review table grants, RLS settings and policies together, using authorised test accounts and test records. In Supabase, enabled RLS with no policies normally denies API access through a publishable key; it does not make the table public. Disabled RLS requires checking whether the relevant roles have access. Test both permitted and denied paths before release. | No. Writing correct RLS policies requires understanding your schema and auth model in combination. Guessing creates data leaks. |
| Every prompt fixes one thing and breaks two others | Incomplete instructions, incompatible edits, missing dependencies or stale assumptions can cause regressions. Session length alone does not diagnose the cause. Preserve the current state, read the logs and compare the last changes against the previously working version before making another patch. | Pause repeated unsuccessful patches. Save the state and inspect the error and recent changes; seek help if the cause remains unclear. |
| API keys visible in browser dev tools | Possible cause: An actual privileged secret may have been included in the frontend bundle. Confirm the credential type and usage. Move privileged calls to a trusted server; a browser preview does not establish that the application must be client-only. | If a privileged secret is actually exposed, rotate it and review usage. Confirm the credential type first; publishable keys and variable names are not automatically secret leaks. |
| Database rows readable by anyone | Review table grants, RLS settings and policies together, using authorised test accounts and test records. In Supabase, enabled RLS with no policies normally denies API access through a publishable key; it does not make the table public. Disabled RLS requires checking whether the relevant roles have access. Test both permitted and denied paths before release. | No, but run the triage checklist below immediately. This is not a future problem. |
| Data disappears between sessions or users | Possible cause: Bolt prototypes sometimes store state in memory or local browser storage rather than a real database. What looks like persistence in the preview resets when a real user closes the tab. | Rarely. This is an architectural issue: the data layer needs to be rebuilt, not patched. |
When to pause and investigate
If repeated attempts are not resolving the same error, pause new changes. Save the current state and identify a known working version. Inspect what changed before deciding whether to revert, repair or seek help.
Incomplete instructions, incompatible edits, missing dependencies or stale assumptions can cause regressions. Session length alone does not diagnose the cause. Preserve the current state, read the logs and compare the last changes against the previously working version before making another patch.
The 20 minute triage you can do yourself
Before you pay anyone, run these four checks. Use authorised test records and preserve the current state. The checks help narrow the problem; they do not establish a complete diagnosis or security certification.
- Review table grants, RLS settings and policies together, using authorised test accounts and test records. In Supabase, enabled RLS with no policies normally denies API access through a publishable key; it does not make the table public. Disabled RLS requires checking whether the relevant roles have access. Test both permitted and denied paths before release.
- Review credential types safely. Inspect the app locally without copying credential values into chat or shared logs. Supabase publishable keys are intended to be visible and need access controls; privileged secret keys, service-role keys and actual private API credentials require trusted server storage. Rotate actual exposed secrets and review their use rather than rotating every visible identifier.
- Test intended permissions with authorised test records. In staging, check that logged-out and unauthorised accounts cannot access protected data. An intentionally public endpoint can return data legitimately. Test the intended access policy and avoid retrieving real customer records merely to demonstrate a risk.
- Verify recovery before risky changes. Keep an authorised backup that includes the data and schema needed for recovery, and test restoration separately. A CSV export alone does not capture every constraint, file, user identity or recovery requirement.
If the first two checks came back clean, you may genuinely be dealing with a deployment configuration issue rather than a security one. If either failed, you have a security problem first and a bug second, and the order in which you fix them is not optional. Run our vibe-code security checklist to map every gap before writing a line of fix.
What a rescue actually costs
There is no verified market-price dataset behind this guide. Request an audit-based quote that separates investigation, urgent security work, repair, testing, deployment and ongoing support. The tool used to build the app does not determine the price.
Compare the proposed investigation, security checks, test coverage and handover rather than the supplier's location or job title. A low quote may exclude important work, while a high quote does not establish quality. Ask each supplier to explain its assumptions and exclusions.
What actually moves the cost is the state of the project before rescue work begins:
- No version control. Bolt does not enforce git history. If there is no commit log, every diagnosis starts from scratch with no record of what changed or when.
- Exposed secrets. Every leaked key has to be rotated across every connected service, and anything those keys touched has to be audited.
- Schema chaos. Duplicate tables, missing foreign keys, and data migrations all add time before the app can be stabilised.
- Compliance requirements. Health data, payment card data, or anything involving children raises the bar on what "fixed" has to mean.
If you have realised that what you really have is a validated idea deserving a proper foundation, that is a different conversation about custom app development, not a rescue.
What a professional rescue actually does
A genuine rescue is not "find the bug and close the ticket." It runs in a specific order, because building features on top of a broken foundation just breaks the features:
- We start with an agreed investigation scope and written findings. Further issues may emerge during repair, and any change in scope needs a separate decision.
- Secrets rotated and moved server-side. Every leaked or suspect key replaced and moved out of the frontend where it belongs.
- RLS and proper server-side auth. Row Level Security policies written for your actual data model, and authentication enforced at the server layer, not the UI layer.
- Version control and CI. Save meaningful changes and check critical paths before release. Version history and tests support diagnosis and recovery within their coverage; they cannot guarantee every failure will be detected.
- Proper deployment pipeline. A staging environment that mirrors production so you catch issues before real users do.
- Then your feature list. Deliberately last. On ground that can actually hold it.
This is also the approach we take on our vibe code rescue service, which covers apps built with Bolt, Lovable, Cursor, v0 and Replit. Built with a different AI tool? Lovable, Cursor, v0, and Replit each have their own guide.
Frequently asked questions
Can Bolt fix its own broken app?
An agent may help with an isolated, reproducible bug. Keep the change small and verify it against a saved baseline. Repeated unsuccessful patches are a reason to investigate the logs, dependencies and access controls, not proof of a specific context-window failure.
Should I start over or fix what I have?
Compare rescue and rebuild after inspecting the code, data and requirements. Existing product decisions may be reusable, but missing Git history alone does not require a rebuild. Compare migration risk, retained functionality, testing and ongoing costs before choosing.
How long does a Bolt app rescue take?
A reliable timeline needs an agreed scope after inspection. Access, the failure to reproduce, affected data, integrations, security issues and required release checks all influence it. Ask for an investigation milestone, a repair estimate and a staged release plan; these are not guaranteed turnaround times.
Do I need to stop using Bolt?
No. Bolt is a genuinely fast tool for getting ideas in front of users. The problem is running real customers and their data on prototype infrastructure that was never designed to hold it. After a rescue, many founders keep using Bolt for prototypes and landing pages while the production app lives in a proper repository with version control, tests, and staged deploys. Right tool, right stage.

