# Works on your computer, broken online: what to tell Claude Code

An app that works on your computer but breaks online usually depends on something only your computer had: a key, an address that means your computer, data saved there, or a build step that never ran. Copy what you see and ask Claude Code what's different.

Last checked 17 October 2026.

The same page on the web: https://fline.sh/guides/works-on-my-computer-broken-online

Your app works in the preview on your computer, and online it shows a blank page, an error, or a page that says "not found". That's common, and it rarely means the app is ruined. The copy online runs on a different computer, and something your app quietly took from yours didn't come along. You don't have to find it yourself: copy what you see and hand it to Claude Code with the right question. I build fline, hosting for apps made with Claude Code, so the end of this page says what fline does when something breaks, and what it doesn't. The causes and the prompts apply wherever your app is online.

If your app isn't online yet and only opens for you, that's a different question, and [why your app only works on your computer](https://fline.sh/guides/app-only-works-on-my-computer) answers it.

## Why does my app work on my computer but not online?

Your app works on your computer but not online because the copy online runs on another computer, and it has only what was sent to it. In the preview, your app can lean on your own computer without you noticing. These are the usual things it leans on:

- **A password or key** saved in a file on your computer that never reached the host.
- **An address that means your own computer,** still written in the app or in a service it uses.
- **A database or files** that live on your computer.
- **A rule for inner pages,** so they work when you click to them but say "not found" when you refresh.
- **A build step** that never ran on the host, or ran without the settings it needs.

They're common causes, not a complete list. A mistake in the app's own code can also show up only online, and the same first step finds it.

## What should I do first when my app breaks online?

Copy what you see before you change anything. Write down the address of the page, what you clicked and what appeared, and take a screenshot.

If the page is blank, the real message is usually hidden in your browser's tools for developers. In Chrome, right-click the page, choose Inspect, then open the Console panel. You can also press Cmd + Option + J on a Mac, or Ctrl + Shift + J on Windows. Copy what it shows, especially lines marked as errors.

Then hand it all to Claude Code in your project folder:

```prompt
My app works on my computer but shows [WHAT YOU SEE] online, at [THE LINK]. Here's what I did and what appeared: [PASTE]. What's different between my computer and the host, and what's the smallest fix?
```

Whether Claude Code finds the fix depends on Claude Code and on what it can see, so paste as much of the real message as you can.

## Is a password or key missing online?

Often it is. Keys your app uses, like a payment or email key, usually sit in a settings file on your computer, often named .env, and that file is normally left behind on purpose because it holds secrets. The host needs its own copy of each key, typed into its own settings.

Signs it's a key: the page loads, but signing in, paying, sending email or an AI feature fails, or an error mentions a missing key or "unauthorized".

```prompt
List the keys and settings my app needs online, and tell me which ones the host doesn't have yet. Don't ask me to paste any key into the chat.
```

Two more things catch people out. Payment services usually give you a test key and a live key, and only the live one takes real payments. And on many hosts, a key you add reaches your app only when it starts again or a new version goes online. [Vercel's own guide](https://vercel.com/docs/environment-variables), for example, says a change to these settings applies only to versions put online after it, not to the one already running.

[Where your API keys should go](https://fline.sh/guides/claude-code-api-keys) explains why the chat isn't the place for them.

## Does my app still point at my own computer?

Sometimes it does: the preview gives your app an address that means "this computer", and Claude Code may have written that address into the app while you built it. It works for you, because the app really is running on your computer. For anyone else, it points at their own phone or laptop, where your app isn't.

The same address can hide in services your app uses. A sign-in through another service usually sends people back only to addresses listed in that service's own settings, so it may send them to the preview, or refuse. A payment service that tells your app when someone has paid needs your online address too.

```prompt
Search the code for any address that points at my own computer, and tell me what it should be online. Then tell me which outside services, like sign-in or payments, need my online address added in their own settings.
```

If you later move your app to a web address you own, like www.yourbakery.com, add that address in those services too.

A second version of this problem stays hidden in the preview: an app set to answer only on the computer it runs on. That works while you're on the same computer, and online no visitor can reach it. On fline, an app set up that way is refused with a reason.

## Does my app keep its data on my computer?

If it saves sign-ups, bookings or uploaded files on your computer, the copy online can't reach them. A database that runs on your computer, or a single file of data inside your project, works while you test. Online, your app needs a database that's online too, and a new one starts empty: what you saved while testing stays on your computer.

Files are a second trap. On many hosts, files your app saves into its own folder disappear when a new version goes online, so uploads need somewhere meant to keep them.

```prompt
Where does my app keep what people save, like sign-ups and uploaded files? Will that work online, and will it still be there after an update?
```

[Do I need a database for my app?](https://fline.sh/guides/database-for-your-app) explains what a database is for and how to tell whether you need one.

## Why does a page say "not found" when I refresh it?

Because many apps are one page that changes what it shows as you click, and the host has only that main page. When you click from the home page to your bookings page, the app draws it in your browser. When you refresh, or open the bookings address directly, the browser asks the host for that address, and the host finds nothing there.

The fix is a rule on the host that sends those addresses to the app's main page, so the app can show the right screen. Each host sets it its own way. [Netlify's guide](https://docs.netlify.com/manage/routing/redirects/rewrites-proxies/) gives a one-line rule, and [Vercel's guide for apps built with Vite](https://vercel.com/docs/frameworks/frontend/vite) says direct links to inner pages don't work out of the box and shows the rule to add.

```prompt
On my live app, [PAGE ADDRESS] says not found when I refresh it, but works when I click to it from the home page. Set up my host so a refresh on any page opens the app instead of "not found", and tell me how to check it.
```

## Why is my page blank after I put it online?

A blank white page usually means your app's code stopped before it could draw anything. A common reason is the build step, the step that turns your project into the finished files a browser runs.

In the preview, a tool on your computer prepares those files as you go, so you never see this step. Online, the host has to run it. If it didn't run, the host may hand the browser files it can't use. If it ran without a setting the page needs, the app can stop as soon as it starts.

That second case is common. In apps built with Vite, a tool for building web apps, settings whose names start with `VITE_` are written into the page when it's built. If one was missing on the host at that moment, adding it later changes nothing until the app is built again. Vite's own guide also says these settings shouldn't hold secret keys, because they end up in the page itself.

```prompt
My app shows a blank page online. Check that its build step runs on the host, that every setting the page needs exists when it's built, and that none of those settings is a secret key.
```

## Is the live app the latest version?

Not always: sometimes what you see online is an older copy. Your browser may show a copy it saved earlier, so open the link in a private window to check.

Some app builders put changes online only when you ask. Lovable's guide to publishing says it puts a snapshot of your project online, and changes aren't pushed to your live app until you click Publish, then Publish changes. Its preview always runs your latest work, while visitors see the snapshot you last published. So if your Lovable preview works and the published app is blank or broken, publish your latest changes first. If it still breaks, copy what you see and use Lovable's own help: its FAQ suggests going back to an earlier version if a recent change broke something.

## When should I ask a person for help?

Ask a person when your app already has customers, or when Claude Code has gone round in circles twice on the same problem. Someone who codes can read the same message and tell you whether the problem is in your app or at the host. If Claude Code says the problem is on the host's side rather than in your app, send your host what you copied.

## Where fline fits

fline is hosting for apps you build with Claude Code on your own computer. It doesn't fix mistakes in your app's own code, and it doesn't check that code. What it does is give Claude Code something to work with when your app breaks:

- **Building it.** fline works out how to build and run your app, so there are no setup files to write.
- **When a launch or an update fails,** your fline dashboard says so, and one button copies the problem for Claude Code. fline emails you when a build starts, when your app goes live, and if it can't get your app built and started.
- **What your app printed.** Your dashboard can search the last 7 days of it. Claude Code gets only the most recent lines, so ask it while the problem is happening.
- **Updates.** The current version keeps running while the new one is prepared.
- **Putting an earlier version back.** Ask Claude Code. fline runs exactly what ran then, as a new version, and keeps your current passwords and keys. It doesn't change what's in your database.
- **Keys** go on a private fline page that Claude Code links you to, not in the chat. Claude Code sees that you entered them, not what you typed.
- **A database.** fline can create the database your app needs, and runs it. If connecting it to your app needs you, Claude Code asks you to copy one line from your dashboard.

```prompt
My app on fline shows an error when I [WHAT YOU DID]. Look at what went wrong on fline and try a fix.
```

Claude Code can see what went wrong, try a fix, or put an earlier version back, and whether it finds the fix depends on Claude Code. fline doesn't email you when a running app crashes or stops answering. It doesn't promise that inner pages survive a refresh either, so open one and refresh it after your first launch.

During the private beta every app runs on one rented machine with no spare, with no uptime promise and no backups you can count on. Your app's link is long, ending in apps.dev.fline.sh, until you put it at a web address you own. fline needs your project as a folder on your computer, so it can't take an app straight from a chat or an app builder like Lovable, and [can Claude host my website?](https://fline.sh/guides/can-claude-host-my-website) covers the options there. [What fline does today](https://fline.sh/facts) has the full list, with a date on it. [How to get your Claude Code app online](https://fline.sh/guides/put-claude-code-app-online) walks through a first launch, and [when something goes wrong](https://fline.sh/docs/when-something-breaks) covers fline's own messages.

fline is free during the private beta, with no card. Claude Code's own plan is separate: its work on your app uses your plan as usual. We open accounts by hand, a few at a time.

Built your app with Claude Code, and it runs on your computer? [Ask for early access](#join).

## Questions people ask

### Why does my app work on my computer but not online?

The copy online runs on another computer, and anything your app took from yours without you noticing doesn't come along. The usual causes are a key saved only on your computer, an address in the app that means your own computer, data kept on your computer, a missing rule for inner pages, or a build step that didn't run on the host. Copy what you see online and ask Claude Code what's different between your computer and the host.

### Why is my app a blank white page after I published it?

A blank page usually means the app's code stopped before it drew anything. Common causes are a build step that didn't run on the host, a setting the page needs that was missing when it was built, or a key or address that exists only on your computer. The real error is often in your browser's tools for developers, in the Console panel. Copy it and paste it to Claude Code.

### Why does my page say not found when I refresh it?

Many apps are one page that changes what it shows as you click, so the host has only the main page. A refresh asks the host for the inner page's address directly, and it finds nothing there. The fix is a rule on the host that sends every address to the app's main page, so the app can show the right screen. Each host sets that rule its own way, so ask Claude Code to add it for yours.

### Why does my Lovable app work in the preview but not when published?

Lovable's preview runs your latest work, while visitors see the snapshot you last published, so changes don't reach your live app until you publish again. In Lovable, click Publish, then Publish changes. If the published app still breaks after that, copy what you see and use Lovable's own help: its FAQ suggests going back to an earlier version if a recent change broke something.

### Will fline fix my app if it breaks online?

No. fline doesn't fix mistakes in your app's own code. If a launch or an update fails, your fline dashboard says so, and one button copies the problem for Claude Code. Claude Code can see what went wrong, try a fix, or put an earlier version back, but whether it finds the fix depends on Claude Code.
