# How to deploy a vibe-coded app

What a vibe-coded app needs before other people use it, and the steps to deploy one on floo: a Dockerfile, one floo.app.toml, floo deploy, Postgres, sign-in, secrets kept out of the code, and a way to roll back.

Canonical URL: https://getfloo.com/blog/how-to-deploy-a-vibe-coded-app

## TL;DR

**To deploy a vibe-coded app, put the code in git, add a Dockerfile, describe the app in one `floo.app.toml`, and run `floo deploy`. The same file gives it Postgres, sign-in, and scheduled jobs, so the app is ready for other people and not only running.**

- An app that works on your machine is missing five things: a server, a database that persists, sign-in, secrets kept out of the code, and a way to roll back.
- Your agent can do the whole deploy. Every command returns JSON and each error names the next step.
- Start invite-only. Open the app to the public when you have checked what it exposes.
- If the app is a static page with no data, use a static host instead.

## What changes when other people use it

Your agent built something that runs when you start it. The moment a teammate or a customer opens it, the app needs things your laptop was quietly providing.

1. **A server that keeps running.** Not your terminal session.
2. **A database that persists.** A local file or an in-memory store disappears on the next deploy.
3. **Sign-in.** A link that anyone can open is a link anyone can open.
4. **Secrets outside the code.** API keys pasted into source files end up in git history.
5. **A way back.** The next change your agent makes will sometimes be wrong.

Most deploy guides cover the first one. The other four are where vibe-coded apps get into trouble, and they are cheaper to set up on day one than after something leaks.

## Deploy it on floo

floo runs any app with a `Dockerfile` that listens on `0.0.0.0:$PORT`. If the app lives in a browser-based builder, export the code to a git repository first; how you do that depends on the tool.

The fastest way is to hand your agent this prompt. Replace `my-app` with your app's name.

```text
Deploy this app to floo. App name: my-app.
1. Install the floo CLI if `floo --version` fails: curl -fsSL https://getfloo.com/install.sh | bash. Then run `floo auth login` and have me approve the sign-in.
2. If there is no Dockerfile, add one following https://getfloo.com/docs/guides/dockerfiles.md. If there is no floo.app.toml, run `floo init my-app`. Set access_mode = "accounts" under [app] so only invited people can sign in, and add [managed.default] with type = "postgres" if the app stores data. Read DATABASE_URL from the environment.
3. Commit everything with git. Run `git init` first if the folder is not a git repository.
4. Run `floo deploy --preflight --json`, fix every error, and commit the fixes.
5. Run `floo deploy --json` and report the live URL. If the folder has no GitHub remote, use `floo deploy --hosted --json`. If it stops, run the command in error.suggestion and try again.
```

Or by hand:

```bash
curl -fsSL https://getfloo.com/install.sh | bash
floo auth login
floo init my-app
git init   # only if the folder is not a git repository yet
git add -A && git commit -m "Deploy to floo"
floo deploy --preflight
floo deploy
```

`floo deploy` deploys from the GitHub repository the folder pushes to. With no remote, `floo deploy --hosted` has floo host the code, so you need no GitHub account. It ends with the live URL at `https://<app>.getfloo.app`. floo has no free plan, so a new account adds a card and buys credits before its first deploy.

## The one file

Everything the app needs is declared in `floo.app.toml`, which lives in the repository where your agent can read and change it:

```toml
[app]
name = "my-app"
access_mode = "accounts"

[services.web]
type = "web"
path = "."
port = 3000
ingress = "public"

[managed.default]
type = "postgres"
```

- `access_mode = "accounts"` puts floo's invite-only sign-in in front of the app. Your code reads the signed-in person from the `X-Floo-User-Email` header and contains no auth code. See [App sign-in](https://getfloo.com/docs/guides/app-auth).
- `[managed.default]` gives the app Postgres and sets `DATABASE_URL`. See [Postgres](https://getfloo.com/docs/guides/postgres).
- A `[cron.<name>]` block runs a command on a schedule. See [Cron jobs](https://getfloo.com/docs/guides/cron-jobs).

## Before you share the link

- **Invite people instead of opening the app.** `floo apps invite teammate@example.com --app my-app` sends a one-time link. Everyone else is refused before a request reaches your code.
- **Move secrets out of the code.** `floo env set KEY --stdin` stores a value outside git. `floo deploy` stops when git would commit a secret-looking file such as `.env`.
- **Know how to go back.** Find the last good deploy with `floo deploys --app my-app` and run `floo rollback my-app <deploy-id> --yes`. See [rollbacks](https://getfloo.com/docs/guides/rollbacks).
- **Check what the app exposes.** The [backend checklist](https://getfloo.com/blog/backend-checklist-before-you-share-an-ai-built-app) lists what to look at before anyone outside your team gets the link.

To let customers in, set `access_mode = "public"` and read [Deploy a customer-facing app built with AI](https://getfloo.com/docs/deploy/customer-app).

## When floo is the wrong choice

A static site with no data and no sign-in belongs on a static host; it will be simpler and cheaper. And if you want a vendor's own agent to build and host the app inside a browser editor, stay in that editor. floo is for the app you want to keep changing with your own agent and run for real users.

Related: [where to host an app built with Claude Code](https://getfloo.com/blog/where-to-host-an-app-built-with-claude-code), [how to deploy an app you built in Cursor](https://getfloo.com/blog/deploy-an-app-you-built-in-cursor), and [the best backend for vibe-coded apps](https://getfloo.com/blog/best-backend-for-vibe-coded-apps).

## FAQ

### How do I deploy a vibe-coded app?

Get the code into a git repository, add a Dockerfile that listens on 0.0.0.0:$PORT, run floo init <name>, and run floo deploy. floo builds the app and serves it at a getfloo.app URL. A folder with no GitHub remote takes floo deploy --hosted, and floo hosts the code.

### What does a vibe-coded app need before I share it?

Five things: a server that keeps running, a database that persists, sign-in so only the right people get in, secrets stored outside the code, and a way to roll back a bad change. On floo the first four are lines in floo.app.toml and the fifth is one command.

### Can my coding agent deploy the app for me?

Yes. Give Claude Code, Cursor, or Codex the prompt in this post. Every floo command takes --json, and when a deploy stops the error names the next command, so the agent can fix the problem and try again. You approve one sign-in in your browser.

### How do I keep API keys out of a vibe-coded app?

Do not commit them. Run floo env set KEY --stdin to store each value outside git, and have the app read it from the environment. floo deploy refuses to continue when git would commit a secret-looking file such as .env.
