> ## Documentation Index
> Fetch the complete documentation index at: https://getfloo.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Move from Vercel to floo

> Move a Next.js app, its env vars, scheduled jobs, database, and domain from Vercel to floo.

Move a Next.js app from Vercel to floo with a `Dockerfile` and `floo.app.toml`. Move its env vars, scheduled jobs, database, and domain as you deploy.

Requires the app's code in a GitHub repository, the [floo CLI](https://getfloo.com/docs/guides/install.md) signed in with `floo auth login`, and the [Vercel CLI](https://vercel.com/docs/cli) linked to the project. Without a GitHub repository, `floo deploy --hosted` deploys from a copy floo hosts; see [Deploy without a GitHub repository](https://getfloo.com/docs/deploy/without-github.md).

## What maps to what

| On Vercel | On floo |
| - | - |
| A push to the production branch deploys production | A push to the default branch deploys **dev**. A GitHub release publishes **prod** ([environments](https://getfloo.com/docs/guides/environments.md#the-flow)) |
| A preview deployment for every branch and pull request | A preview per pull request once `[github] preview_environments = true` ([previews](https://getfloo.com/docs/guides/preview-environments.md)) |
| Framework detection, `buildCommand`, `installCommand`, `outputDirectory` | A `Dockerfile` that serves on `0.0.0.0:$PORT` ([Dockerfiles](https://getfloo.com/docs/guides/dockerfiles.md)) |
| `redirects`, `rewrites`, `headers` in `vercel.json` | `redirects()`, `rewrites()`, `headers()` in `next.config.js`, served by the Next.js server |
| `functions` memory and `regions` | `cpu`, `memory`, `min_instances` in [`[resources]`](https://getfloo.com/docs/reference/config-spec#resources) |
| `crons` in `vercel.json` | `[cron.<name>]` in `floo.app.toml` ([cron jobs](https://getfloo.com/docs/guides/cron-jobs.md)) |
| Environment Variables (Development, Preview, Production) | `floo env` with `--env dev` or `--env prod` ([env vars](https://getfloo.com/docs/guides/environment-variables.md)) |
| Marketplace Postgres (Neon, Supabase, and others) | `[managed.default]` with `type = "postgres"`, `DATABASE_URL` injected ([Postgres](https://getfloo.com/docs/guides/postgres.md)) |
| Vercel Authentication on all deployments | `access_mode = "accounts"`: App sign-in for people you invite ([App sign-in](https://getfloo.com/docs/guides/app-auth.md)) |
| Instant Rollback | `floo rollback` ([rollbacks](https://getfloo.com/docs/guides/rollbacks.md)) |
| Domains in project settings | `[domains."<host>"]` in `floo.app.toml` ([custom domains](https://getfloo.com/docs/guides/custom-domains.md)) |

## 1. Add a Dockerfile

Set `output: "standalone"` in `next.config.js` and copy the [Next.js Dockerfile](https://getfloo.com/docs/guides/dockerfiles.md#nodejs-nextjs). The standalone server reads `PORT`, and `HOSTNAME=0.0.0.0` makes it listen on every interface. Add a `.dockerignore` with `node_modules`, `.next`, and `.env*`.

Move `redirects`, `rewrites`, and `headers` from `vercel.json` into `next.config.js` in the same commit. The other `vercel.json` keys have no effect on floo; delete the file once the cron jobs below are moved.

## 2. Write floo.app.toml

```bash theme={null}
floo init my-app
```

For a Next.js app with Postgres, team sign-in, a daily job, and a custom domain:

```toml floo.app.toml theme={null}
[app]
name = "my-app"
access_mode = "accounts"

[services.web]
type = "web"
path = "."
port = 3000
ingress = "public"
dev_command = "npm run dev"

[managed.default]
type = "postgres"

[cron.daily-report]
schedule = "0 9 * * *"
command = "node scripts/daily-report.mjs"
service = "web"

[domains."app.example.com"]
service = "web"
```

Leave out `access_mode` for a public app; a new app on your GitHub repository starts `public`. An app floo hosts starts `accounts`, so set `access_mode = "public"` there. [Deploy a customer-facing app](https://getfloo.com/docs/deploy/customer-app.md) covers a public prod with sign-in on dev and previews. The domain block takes effect with the first prod release ([step 7](#7-move-the-domain)).

```bash theme={null}
floo deploy --preflight
```

## 3. Import env vars

`vercel env pull` writes a project's variables to a file. Exclude Vercel variables and the old database connection strings; floo injects `DATABASE_URL` and `PG*` for managed Postgres. Add `.env.vercel` and `.env.import` to `.gitignore` before creating them:

```bash theme={null}
vercel env pull .env.vercel --environment=production
grep -v -E '^(VERCEL_|POSTGRES_|PG[A-Z]*=|DATABASE_URL)' .env.vercel > .env.import
```

Keep both files outside git. Import `.env.import` after the first deploy creates the app.

floo passes every `NEXT_PUBLIC_*` variable to the build as a Docker build arg. The Dockerfile's build stage must declare it with `ARG` and `ENV`, or the bundle has `undefined` baked in. See [Build-time env vars](https://getfloo.com/docs/build/nextjs.md#2-build-time-env-vars-next_public_).

If the app has its own sign-in library, keep it, and add the new floo host to its callback URLs.

## 4. Move the cron jobs

Vercel calls a cron job's `path` with an HTTP `GET` on the production deployment. floo runs a job's `command` in a new container from the service's image, with the same env vars and no server running. Move the route handler's logic into a script and point the job at it:

```json vercel.json theme={null}
{
  "crons": [{ "path": "/api/cron/daily-report", "schedule": "0 9 * * *" }]
}
```

```toml partial theme={null}
[cron.daily-report]
schedule = "0 9 * * *"
command = "node scripts/daily-report.mjs"
service = "web"
timeout = 300
```

Vercel's docs now call Cron Jobs a legacy feature moving to Schedules; the mapping is the same. Both platforms read the schedule in UTC. A floo job runs for up to 1,500 seconds and does not retry. Copy `scripts/` into the Dockerfile's final stage; the standalone output includes only the packages the server imports, so a script that needs more must have them in the image too ([layer order](https://getfloo.com/docs/guides/dockerfiles.md#layer-order)). Once the script handles the work and nothing else calls the route, remove the cron route and its `CRON_SECRET` check. Run the job by hand after the first deploy.

## 5. Deploy to dev

```bash theme={null}
git add . && git commit -m "chore: move to floo"
floo deploy
```

The first `floo deploy` stops with one link if floo can't read the repository yet. Install the floo GitHub App on the repository's owner, then run `floo deploy` again. It waits until the dev deploy is live, and `floo status --app my-app --json` shows why if it is not. The first build or startup can fail if it needs variables that have not been imported yet. Once the app exists, import them and rebuild:

```bash theme={null}
floo env import .env.import --app my-app
floo env list --app my-app
floo deploy --rebuild --app my-app
```

New keys are secrets except for build-time prefixes. Review the values before importing them to dev; use test credentials for services that must not receive dev traffic. Keep `.env.import` until you have imported the prod values in step 7; then delete both files.

Test the scheduled job after the deploy:

```bash theme={null}
floo cron run daily-report --app my-app
```

Invite the people who signed in through Vercel Authentication:

```bash theme={null}
floo apps invite teammate@example.com --role member --app my-app
```

While `access_mode = "accounts"`, floo's sign-in page sits in front of every request, and only invited people get in.

## 6. Move the database

The dev deploy creates the managed database. Dump the Vercel-side database with its non-pooled connection string and a `pg_dump` at least as new as its server, then load the dump into floo's dev database with `psql`:

```bash theme={null}
pg_dump --format=plain --clean --if-exists --no-owner --no-privileges --file app.sql "$SOURCE_DATABASE_URL"
floo run --service web -- psql --single-transaction --set ON_ERROR_STOP=1 --file app.sql
floo db query --app my-app "SELECT COUNT(*) FROM information_schema.tables WHERE table_schema = 'public'"
```

For a Supabase database, add `--schema=public` to `pg_dump`; Supabase's own schemas do not restore elsewhere. `floo run` sets the `PG*` variables for the dev database, so `psql` connects with no connection string. With a custom-format dump, convert it first with `pg_restore --clean --if-exists --no-owner --no-privileges --file app.sql app.dump`.

Restore before you set `migrate_command`: the dump carries your migration tool's history table, so the first migration run after it finds nothing to apply.

`floo run` opens a dev session, so these commands load dev. Prod gets its own database with the first release ([step 7](#7-move-the-domain)). After that release, load the same file into prod with prod's `DATABASE_URL`:

```bash theme={null}
psql --single-transaction --set ON_ERROR_STOP=1 --file app.sql "$(floo env get DATABASE_URL --app my-app --env prod --reveal-secrets)"
floo db query --app my-app --env prod "SELECT COUNT(*) FROM information_schema.tables WHERE table_schema = 'public'"
```

`floo env get` needs a write-scoped floo API key, and each read is audited. `--reveal-secrets` lets it print a connection string, and the command substitution keeps the URL out of your shell history. `--clean --if-exists` in the dump drops each table before recreating it, so the load also works after the release's `migrate_command` has created the schema. To export a managed database, see [`floo db dump`](https://getfloo.com/docs/cli/database#dump).

## 7. Move the domain

A custom domain serves prod. Replace `owner/repo` with your GitHub repository and publish the first release:

```bash theme={null}
gh release create v1 --repo owner/repo
floo env import .env.import --app my-app --env prod
gh release create v2 --repo owner/repo
floo domains show app.example.com --app my-app
```

Prod env vars apply with the next release, which is why the import sits between two releases. After the first release creates the prod database, restore and verify its data before changing the traffic record. Delete `.env.vercel` and `.env.import` after verifying the prod import. `floo domains show` prints two records:

| Purpose | Type | Name | Target |
| - | - | - | - |
| Certificate | CNAME | `_acme-challenge.app.example.com` | The target floo prints |
| Traffic | CNAME | `app.example.com` | `edge.getfloo.com` |

Lower the record's TTL a day ahead, as [Vercel recommends](https://vercel.com/docs/domains/working-with-dns). Publish the certificate record first; it does not change where traffic goes. Then replace Vercel's traffic record (the `A` record or `CNAME` shown in the Vercel project's **Domains** settings) with the floo one. For an apex such as `example.com`, use an `ALIAS` or `ANAME` to `edge.getfloo.com`, or an `A` record to `34.117.26.37`.

```bash theme={null}
floo domains watch app.example.com --app my-app
```

Keep the Vercel project until the domain is `active`. Pointing the traffic record back at Vercel is the move's rollback.

## Roll back on floo

Choose a deploy ID from the list, check its environment, and replace `DEPLOY_ID`:

```bash theme={null}
floo deploys --app my-app --env prod
floo rollback my-app DEPLOY_ID
```

A rollback re-points traffic at an earlier image. It does not run `migrate_command` or revert env vars. See [Releases and rollbacks](https://getfloo.com/docs/guides/rollbacks.md).

## Previews

Vercel builds a preview for every branch push and pull request. On floo, previews are off until you turn them on, and each pull request then gets its own URL and its own Postgres branch:

```toml partial theme={null}
[github]
preview_environments = true
preview_ttl_hours = 72
```

`/floo preview on` in a pull request comment turns one on for that PR alone. Most apps that move from Vercel need dev and prod first; see [Preview environments](https://getfloo.com/docs/guides/preview-environments.md).

## Agent prompt

Paste into your agent from the repository root. Replace `my-app`, `app.example.com`, and `<owner/repo>`.

```text theme={null}
Move this Next.js app from Vercel to floo. App name: my-app. Read https://getfloo.com/docs/migrate/from-vercel.md first.
1. Confirm the floo org with `floo orgs list`. If the org has no plan, have me run `floo billing upgrade`.
2. Set output: "standalone" in next.config.js. Add the Next.js Dockerfile from https://getfloo.com/docs/guides/dockerfiles.md and a .dockerignore with node_modules, .next and .env*. Declare every NEXT_PUBLIC_* variable the code reads with ARG and ENV in the build stage.
3. Move redirects, rewrites and headers from vercel.json into next.config.js.
4. Run `floo init my-app`. In floo.app.toml set port 3000 on [services.web]. Add [managed.default] with type = "postgres" if the app uses Postgres. Ask me whether the app is for invited people only; if so, set access_mode = "accounts" under [app].
5. For each entry in vercel.json crons, move the route handler's logic into a script under scripts/, copy scripts/ into the Dockerfile's final stage, and add a [cron.<name>] block with the same schedule, command = "node scripts/<name>.mjs" and service = "web". Remove each cron route only after checking nothing else calls it; remove vercel.json only after accounting for its other settings.
6. Add .env.vercel and .env.import to .gitignore. Run `vercel env pull .env.vercel --environment=production`. Write every line that does not start with VERCEL_, POSTGRES_, PG or DATABASE_URL to .env.import. Never print the values or commit either file.
7. Commit with git, then run `floo deploy --preflight --json` and fix every error. Commit any resulting changes.
8. Run `floo deploy --json`. If it stops with a GitHub setup link, give me the link and wait for me to install the floo GitHub App, then run it again. Once the app exists, import .env.import with `floo env import .env.import --app my-app` and run `floo deploy --rebuild --app my-app`. Keep the files for the prod import, then delete them.
9. If the app has a database, ask me for the source database's non-pooled connection string as SOURCE_DATABASE_URL in my shell. Run `pg_dump --format=plain --clean --if-exists --no-owner --no-privileges --file app.sql "$SOURCE_DATABASE_URL"` (add --schema=public for Supabase), then `floo run --service web -- psql --single-transaction --set ON_ERROR_STOP=1 --file app.sql`. Compare each table's row count with the source.
10. Run each job with `floo cron run <name> --app my-app` and check `floo logs query --app my-app --cron <name>`.
11. Report the dev URL and `floo status --app my-app --json`. Stop there: I publish the release and change DNS.
```

## Where Vercel is stronger

As of November 9, 2026, from Vercel's documentation:

* **Global delivery.** Vercel's [CDN](https://vercel.com/docs/cdn) runs 126 points of presence in 51 countries. floo's edge cache serves Next.js `/_next/static/*` files for public apps ([edge cache](https://getfloo.com/docs/build/nextjs.md#build-files-from-the-edge-cache)); pages render in your app's container.
* **Next.js without configuration.** Vercel maintains Next.js and [deploys it with zero configuration](https://vercel.com/docs/frameworks/full-stack/nextjs). floo needs a Dockerfile.
* **Managed ISR.** Vercel's CDN runs [Incremental Static Regeneration](https://vercel.com/docs/incremental-static-regeneration) caching on every plan. On floo, ISR uses the Next.js server's own cache inside the container.
* **Previews by default, with comments.** Every branch push and pull request gets a [preview URL](https://vercel.com/docs/deployments/environments), and [Comments](https://vercel.com/docs/comments) on previews are free on all plans. floo previews are opt-in and have no comment toolbar.
* **Image Optimization** is a platform service on [every Vercel plan](https://vercel.com/docs/image-optimization). floo has no separate image service.
* **A free plan.** [Hobby](https://vercel.com/docs/plans/hobby) is free for personal, non-commercial projects. floo's entry plan, Starter, is \$4 a month with 4 credits included.

## What it costs

One small full-stack app, priced as of November 9, 2026:

* One Next.js web service with light traffic, deployed by one person.
* A small Postgres database, about 1 GB.
* Sign-in so about 5 named people can use the app, and nobody else.
* One job that runs once a day.
* Vercel usage stays inside Pro's included \$20 credit. floo's numbers are the personal-app estimate on [getfloo.com/pricing](https://getfloo.com/pricing): "a default-size service (1 vCPU, 0.5 GiB) busy about an hour a day, a 1 GiB database and light traffic. Builds and logs are extra."

| Setup | Per month | What it includes |
| - | - | - |
| Vercel Hobby + Neon Free | \$0 | Hobby is for [non-commercial, personal use only](https://vercel.com/docs/plans/hobby). Viewer seats are [not available](https://vercel.com/pricing), and Vercel Authentication admits [one external user per account](https://vercel.com/docs/deployment-protection/methods-to-protect-deployments/vercel-authentication), so 5 named people do not fit. Daily cron runs within the hour ([cron usage](https://vercel.com/docs/schedules/cron-jobs/usage-and-pricing)). |
| Vercel Pro + Neon Free | \$20 | [Pro](https://vercel.com/docs/plans/pro-plan) is $20 with one deploying seat and $20 of usage credit; each extra deploying seat is \$20. Viewer seats are free, and Vercel Authentication on all deployments is [included](https://vercel.com/docs/deployment-protection/usage-and-pricing); each viewer needs a Vercel account. [Neon Free](https://neon.com/pricing) is available through [Vercel](https://vercel.com/marketplace/neon). |
| Vercel Pro + Neon Launch | \$20 plus Neon usage | [Neon Launch](https://neon.com/pricing) has no monthly minimum; database usage is billed separately. |
| Vercel Pro + Supabase Free | \$20 | [Supabase Free](https://supabase.com/pricing): 500 MB, and a project pauses after 1 week of inactivity. |
| Vercel Pro + Supabase Pro | \$45 | [Supabase Pro](https://supabase.com/pricing) is from $25 with $10 of compute credit and 8 GB of disk per project. |
| Password Protection on Vercel Pro | +\$20 per protected project | For viewers without Vercel accounts ([pricing](https://vercel.com/docs/deployment-protection/usage-and-pricing)). |
| floo Starter, scales to zero | \$10 | The $4 plan includes 4 credits; the other $6 comes from extra credits, bought $10 at a time and never expiring. Web service $5, Postgres $5, sign-in for people and agents included, daily task and traffic under $1 each. 1 builder, 1 app ([pricing](https://getfloo.com/pricing)). |
| floo Starter, always warm | \$25 | Web service \$20 with an instance always ready, the rest as above. |

floo's Pro plan is $25 a month with $25 of credits and 5 builder seats; Team is $250 a month with $250 of credits and 50 builder seats. Rates are on [getfloo.com/pricing](https://getfloo.com/pricing).

## Next steps

> [card] [Build a Next.js app](https://getfloo.com/docs/build/nextjs.md)
>
> Dockerfile, `NEXT_PUBLIC_*` build variables, Prisma migrations, and local development.

> [card] [App sign-in](https://getfloo.com/docs/guides/app-auth.md)
>
> Identity headers, app roles, and sign-out.

> [card] [Production environments](https://getfloo.com/docs/guides/environments.md)
>
> Dev on every push, prod on every release.

> [card] [Custom domains](https://getfloo.com/docs/guides/custom-domains.md)
>
> DNS records, apex domains, and activation.

> [card] [Customer-facing apps](https://getfloo.com/docs/deploy/customer-app.md)
>
> A public prod URL with invite-only dev and previews.

> [card] [A safe backend](https://getfloo.com/docs/guides/backend.md)
>
> Database, sign-in, jobs, and secrets behind your server.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.