A friendlier migration guideNext.js · Neon · Vercel Blob · Cron
Tell us what you use. We build the route: only the steps you need, in the right order.
Start here
Five questions. Switch something off and its steps disappear.
pg_dump and pg_restore), at the newer of the two servers' major versions or newer (for a Neon database on 18, that means 18). Sevalla's page Import and export PostgreSQL says how to get them.| On Vercel | On Sevalla |
|---|---|
| Project | Application, built from your Git repository; it runs next build and then next start |
| Functions, middleware, edge routes | The application's web process (one long-running server per instance) |
Function region (iad1 by default) | A location; Ashburn, USA is next to iad1 (companies on Google Cloud see it as Ashburn, Virginia) |
| Neon (Marketplace Postgres) | A PostgreSQL database |
| Vercel Blob | Object storage: an S3-compatible bucket. Public access gives it a sevalla.storage address |
vercel.json redirects, rewrites, headers | The same rules in next.config.ts |
Cron Jobs (vercel.json crons) | A Cron job process that runs a command (a small script calls your route) |
geolocation() from @vercel/functions | The CF-IPCountry request header |
| Environment variables | Environment variables, available during the build, at runtime, or both |
| Domains | Custom domains; Sevalla issues and renews the certificates |
| Vercel DNS | No equivalent: Sevalla doesn't host DNS. Keep your DNS where it is |
| Preview deployments, Deployment Protection, Edge Config, Neon branches | See the links at the end of the route |
Bold text in the steps is the exact label on screen. Where something needs a terminal, the step says so and you can hand it to a developer or an AI assistant.
next build reads your database to prerender pages. If the database is empty when you deploy, the build fails. So you create the application early but do not deploy it until says so.
The smallest size, H1, can't have one.
Verifying changes nothing for your visitors. Pointing is the moment traffic moves. One exception, because your DNS is on Cloudflare: see .
A Neon database created through Vercel runs PostgreSQL 18 today. Sevalla's docs ask for a database on the same major version or newer, and for client tools at least as new as the newer of the two servers. Sevalla's version list depends on the location. If it doesn't reach your version yet, use the newest one it offers. In our test, a version-18 dump loaded cleanly into PostgreSQL 17 for the example shop, but that goes beyond what Sevalla's docs promise and isn't guaranteed for every schema: pg_restore prints an error if it can't, and Sevalla support can help.
Your database stores full file addresses on Vercel's domain. Restoring a copy of it puts the old addresses back.
Without a custom domain your app lives at its free sevalla.app address and nothing on your visitors' side changes.
Open your project in Vercel. Click Settings, then Build and Deployment: note the Node.js Version. Then click Functions and expand the region group: note the function region. The default, Washington, D.C., USA (East) - us-east-1 - iad1, is next to Sevalla's Ashburn, USA (companies on Google Cloud see Ashburn, Virginia). Choose the Sevalla location closest to yours; you will need the Node.js version in .
Click Environment Variables in the project's sidebar. Write down each variable's name and where its value comes from. The dashboard has no export button (the Vercel CLI's vercel env pull does; see the original guide), so you copy values one by one:
DATABASE_URL and the PG*, POSTGRES_* and NEON_* ones, and BLOB_* for Blob) are not copied. Sevalla creates its own.
Open Observability, then Schedules, then Cron Jobs (Vercel marks this page Legacy, but your job is still listed there as active). Note each job's Path and schedule. Your repository's vercel.json lists the same jobs, plus any redirects, rewrites and headers you will move in .
Click Domains in the project's sidebar and note every domain, and where its DNS is managed (your registrar, or Vercel's nameservers).
Click Storage in the project's sidebar. Your Neon database and your Blob store are listed there.
Ask your developer or assistant to search the code for anything that only works on Vercel: imports of @vercel/blob, @vercel/functions, @vercel/kv, @vercel/postgres, @vercel/edge-config and @neondatabase/serverless (your Git host's code search also finds them). The next step changes every one of them.
Each change replaces something that only Vercel provides. They change package-lock.json, which is why this isn't a dashboard job. Make them on a new branch, here called sevalla.
The Neon serverless driver (@neondatabase/serverless) sends queries over HTTP to Neon's proxy, which a Sevalla PostgreSQL database doesn't have. Postgres.js has the same tagged-template API, so only the import changes. Code that already uses a standard PostgreSQL driver, such as pg, only needs the new DATABASE_URL.
npm uninstall @neondatabase/serverless
npm install postgreslib/db.ts
-import { neon } from "@neondatabase/serverless";
+import postgres from "postgres";
-export const sql = neon(process.env.DATABASE_URL!);
+export const sql = postgres(process.env.DATABASE_URL!);Replace put() from @vercel/blob with the AWS SDK's PutObjectCommand, and build the file's address from the bucket's public domain. crypto.randomUUID() keeps names unique, as addRandomSuffix did. For the other Blob calls, list() becomes ListObjectsV2Command, del() becomes DeleteObjectCommand, and a private file's get() becomes a presigned URL.
npm uninstall @vercel/blob
npm install @aws-sdk/client-s3app/api/upload/route.ts
-import { put } from "@vercel/blob";
+import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
import { sql } from "@/lib/db";
+const s3 = new S3Client({
+ region: "auto",
+ endpoint: process.env.S3_ENDPOINT,
+ credentials: {
+ accessKeyId: process.env.S3_ACCESS_KEY_ID!,
+ secretAccessKey: process.env.S3_SECRET_ACCESS_KEY!,
+ },
+ requestChecksumCalculation: "WHEN_REQUIRED",
+ responseChecksumValidation: "WHEN_REQUIRED",
+});
+
export async function POST(request: Request) {
const token = process.env.ADMIN_TOKEN;
if (!token || request.headers.get("authorization") !== `Bearer ${token}`) {
return new Response("Unauthorized", { status: 401 });
}
const file = (await request.formData()).get("file") as File;
- const blob = await put(`products/${file.name}`, file, {
- access: "public",
- addRandomSuffix: true,
- });
- await sql`INSERT INTO uploads (pathname, url, size) VALUES (${blob.pathname}, ${blob.url}, ${file.size})`;
- return Response.json({ pathname: blob.pathname, url: blob.url });
+ const pathname = `products/${crypto.randomUUID()}-${file.name}`;
+ await s3.send(
+ new PutObjectCommand({
+ Bucket: process.env.S3_BUCKET,
+ Key: pathname,
+ Body: new Uint8Array(await file.arrayBuffer()),
+ ContentType: file.type,
+ }),
+ );
+ const url = `${process.env.S3_PUBLIC_URL}/${pathname}`;
+ await sql`INSERT INTO uploads (pathname, url, size) VALUES (${pathname}, ${url}, ${file.size})`;
+ return Response.json({ pathname, url });
}geolocation() and ipAddress() read headers that only Vercel sets. Every request to Sevalla passes through Cloudflare, which sets CF-IPCountry and CF-Connecting-IP. Cloudflare sends the country only, not a city or a region. Then run npm uninstall @vercel/functions. See Sevalla's Request headers.
proxy.ts
import { NextResponse, type NextRequest } from "next/server";
-import { geolocation } from "@vercel/functions";
export function proxy(request: NextRequest) {
if (request.nextUrl.pathname.startsWith("/account") && !request.cookies.has("session")) {
return NextResponse.redirect(new URL("/", request.url));
}
const response = NextResponse.next();
- response.headers.set("x-visitor-country", geolocation(request).country ?? "unknown");
+ response.headers.set("x-visitor-country", request.headers.get("cf-ipcountry") ?? "unknown");
return response;
}vercel.json rules into next.config.tsSevalla doesn't read vercel.json. Its redirects, rewrites and headers have the same fields in next.config.ts: copy each list into a function, then delete vercel.json (on this branch only). Add the bucket's domain to images.remotePatterns in place of Vercel Blob's. permanent: true answers 308, as on Vercel. A redirect from one domain to another, which you set in Vercel's domain settings rather than in vercel.json, becomes a redirect with a has host condition.
next.config.ts
import type { NextConfig } from "next";
const nextConfig: NextConfig = {
images: {
remotePatterns: [{ protocol: "https", hostname: "*.sevalla.storage" }],
},
async redirects() {
return [{ source: "/shop", destination: "/products", permanent: true }];
},
async rewrites() {
return [{ source: "/catalog.json", destination: "/api/products" }];
},
async headers() {
return [
{
source: "/(.*)",
headers: [{ key: "X-Frame-Options", value: "DENY" }],
},
];
},
};
export default nextConfig;A Vercel Cron Job sends a GET request to a path, with Authorization: Bearer <CRON_SECRET>. A Sevalla cron job runs a command instead, so this script sends the same request to your web process. Your route keeps its CRON_SECRET check. Vercel also sends an x-vercel-cron-schedule header; if your route reads it, pass the schedule another way.
scripts/cron.mjs
// Calls a route the way Vercel Cron Jobs do: GET with the CRON_SECRET as a bearer token.
const response = await fetch(new URL(process.argv[2], process.env.APP_URL), {
headers: { authorization: `Bearer ${process.env.CRON_SECRET}` },
});
console.log(response.status, await response.text());
if (!response.ok) process.exit(1);Node.js version. Sevalla's builder, Ingot, uses Node.js 24 unless your project says otherwise: a .nvmrc or .node-version file, or engines.node in package.json (or an INGOT_NODE_VERSION variable that is Available during buildtime). If the version you noted in isn't 24, pin it.
Make sure nothing else imports a package you removed (the search from ): in our example project, a one-off seed route imported @vercel/blob and had to go before the build would pass. Then commit everything, package-lock.json included, and push the branch:
git checkout -b sevalla
git add -A
git commit -m "Move from Vercel to Sevalla"
git push -u origin sevallaSevalla's tools have no way to upload files to a bucket or to import a database dump, and they can't change your DNS or touch Vercel.
The server's address is https://mcp.sevalla.com/mcp. Sevalla's own pages say how to connect each assistant (Claude on desktop and web, Claude Code, Cursor, Codex, and others); follow the page for yours. Sign-in happens in your Sevalla dashboard: on the Authorize page you pick the company and set the permissions, then click Authorize.
The assistant can do exactly what the key behind the connection allows. A role such as Company admin lets it delete applications and databases, which you can't undo. Approving creates an API key named "Sevalla MCP …" under Tools, API keys; disable or delete it when you are done. Environment variable values and database passwords are never sent back to the assistant, but the bucket's access keys, command output and logs can contain secrets, so treat the conversation as private.
Have two things ready: your code changes pushed on the sevalla branch (), and your own variables from . Leave out the Vercel and integration variables (VERCEL*, TURBO_*, NX_DAEMON, BLOB_*, DATABASE_URL, PG*, POSTGRES_*, NEON_*, VITE_NEON_*) and PORT, which Sevalla sets. Replace any value that contains your Vercel address with your sevalla.app address.
It follows your route and your names. Fill in the angle-bracket parts; the assistant does the rest. Change the location if your Vercel region isn't iad1.
Not sure what an assistant did? Open the dashboard: everything it creates appears there, with the same labels as the dashboard steps. This table says which tool each step uses.
| Step | Tool | Notes |
|---|---|---|
| Locations and sizes | get_platform_options | Returns the IDs the other tools need |
| Create the application | create_application with deploy: false | In our test the web process started at S1 (the dashboard form can start on H1): check with get_application, and if it says H1 raise it with scale_process (size_id, apply_now: false). Without deploy: false the application deploys at once, too early |
| Create and connect the database | create_database with connect_to_application_id | Creates the internal connection and stores the URL in DATABASE_URL (the default name), available at build time and runtime. Check the variable with list_environment_variables (it shows build and runtime) and readiness with get_database |
| Open the database to your computer | sevalla_api_update with toggleDatabaseExternalConnectionV3 | Optional: you can also do it in the dashboard. The dump and restore are still yours |
| Create the bucket | sevalla_api_create with createObjectStorageV3 and public_access: true (or false) | The response has the public domain, endpoint, bucket name and keys |
| Environment variables | set_environment_variables | All variables in one call; values aren't echoed. Check with list_environment_variables |
| Cron job | sevalla_api_create with createProcessV3 (type cron) | Use the smallest size ID from get_platform_options |
| Domain | add_domain, then get_application | get_application lists the DNS records and any verification errors |
| Deploy and watch | trigger_deployment, get_deployment, get_deployment_logs | |
| Run the cron job | sevalla_api_update with triggerProcessCronV3 | Then search_runtime_logs for the script's line |
| Auto-deploy | sevalla_api_update with updateApplicationV3 and {"auto_deploy": true} |
The dashboard steps for these jobs are left out of your route, because the assistant does them. Switch Setting up Sevalla back to the dashboard at the top if you'd rather click.
storefront-db as the Display name.In Oracle Cloud (OCI) locations the form also has a Backups section: External backups is on by default and creates a second bucket named like storefront-db-backups, billed as object storage. That is expected.
storefront-files as the Name, choose the Location closest to your app (here Eastern North America), and click Create object storage. Sevalla turns the name into a bucket name such as storefront-files-x7k2m.
On the bucket's Settings tab, in Public access, click Enable public access, then click Enable public access in the dialog. Public domain now shows the address, such as storefront-files-x7k2m.sevalla.storage. Public access makes every file in the bucket readable by anyone with its address.
Your Blob store is private, so keep its files in a private bucket and share them with presigned URLs. The original guide's copy script has a private-store option.
sevalla Branch.APP_URL later, comes from it) and, if your company has projects, choose one.The application opens with the status Not deployed yet. The Auto-deploy switch on the form isn't applied: new applications start with automatic deployments off, and you turn them on in .
The application opens with the status Not deployed yet. The Auto-deploy switch on the form isn't applied: new applications start with automatic deployments off, and you turn them on in .
storefront-db as the Service and turn on Add environment variables to the application. Keep Available during runtime and Available during build ticked.DB_URL row and change its key to DATABASE_URL.
The panel shows the values in plain text, passwords included: don't screenshot or share it. The URL starts with postgres:// and has no sslmode, because the connection stays inside the data center. Code that forces TLS for Neon, such as ssl: "require" in the driver options, must drop it. The other DB_* variables it adds are harmless.
A variable called DATABASE_URL is already there, so the panel won't save. Delete the old one on the Environment variables tab, reload the panel, and try again. (The next step never adds DATABASE_URL by hand, which avoids this.)
In a text editor, write one KEY=value per line: your own variables from , the new secrets, and the values in the table. Leave out the Vercel and integration variables (VERCEL*, TURBO_*, NX_DAEMON, BLOB_*, DATABASE_URL, PG*, POSTGRES_*, NEON_*, VITE_NEON_*) and PORT, which Sevalla sets. Replace any value that contains your Vercel address with your sevalla.app address. Code that reads VERCEL_URL or VERCEL_ENV needs a variable of your own instead.
When you paste or import a .env list, Sevalla removes the quotes around values (and export and trailing # comments), so NAME="Storefront" becomes Storefront; we tested this. If you instead type a value into the form's Value box, don't add quotes: they would be saved as part of the value.
Variables of Vercel's Preview environment belong to preview apps (see the original guide). Your Development values stay in your local .env.local: Sevalla has no development environment.
node scripts/cron.mjs followed by the job's path as the Custom start command.In vercel.json | On Sevalla |
|---|---|
{ "path": "/api/cron", "schedule": "0 5 * * *" } | Custom start command node scripts/cron.mjs /api/cron, Schedule 0 5 * * * |
The new job shows Not run yet, and the application shows undeployed changes. You deploy in .
Vercel's Hobby plan runs a cron job once a day at most, at any minute within the hour. A Sevalla cron job runs at the minute you set, as often as every minute.
Vercel keeps serving the domain. (Your DNS is on Cloudflare: see the Cloudflare note below. That one is different.)
Your assistant already added (it is in the prompt). Open the application's Domains tab and its DNS records sheet to see the records; the status is Verification. Sevalla's custom domains page shows these screens.
At your DNS provider, add the two TXT records the sheet shows: _cf-custom-hostname (proves ownership) and _acme-challenge (lets the certificate be issued; keep it for renewals). Copy them with the copy buttons. Some providers add your domain to the name for you; use the short name there. Leave the A or CNAME record that points at Vercel where it is: the verification records have different names, and Vercel keeps serving the domain meanwhile, as Sevalla's technical guide says. Delete only older verification records left from an earlier attempt. You replace the pointing record in .
Add the records in the domain's DNS records in your Vercel account, or hand these to a developer. A record you add for the domain overrides the one Vercel creates for the project, which is how you point it later:
vercel dns add example.com _cf-custom-hostname.shop TXT <value shown>
vercel dns add example.com _acme-challenge.shop TXT <value shown>
vercel dns add example.com @ CAA '0 issue "pki.goog"'Vercel's DNS adds a CAA record for Let's Encrypt, so a domain that uses Vercel's nameservers needs the one above: name @, type CAA, value 0 issue "pki.goog" (Sevalla's certificates come from Google Trust Services).
Add one that lets Sevalla's certificates be issued: name @, type CAA, value 0 issue "pki.goog" (Sevalla's certificates come from Google Trust Services). If your zone has no CAA records, you don't need one.
Sevalla detects it and asks for a CNAME in place of the ownership TXT. That CNAME is also the record that points visitors at Sevalla, so adding it moves your traffic. Add the _acme-challenge TXT record now, but add the CNAME only inside the window, right before , as a DNS only (grey cloud) record until the domain is Active. Set the zone's SSL/TLS mode to Full or Full (strict) before you turn the proxy on. If the zone restricts certificate authorities, add the CAA record 0 issue "pki.goog". See Domains on Cloudflare DNS.
Click Refresh records. Verification usually completes within minutes and can take hours with some providers. When it completes, both records show Verified and the status changes to Pointing, which means the certificate is ready. Visitors keep reaching Vercel the whole time. Sevalla keeps checking for 7 days: a domain still in Verification after that becomes Timed out, and you have to delete it and add it again, so add the records soon after adding the domain.
If something goes wrong, you haven't pointed your domain yet, so you can resume Vercel. While Vercel is paused, visitors see an error page, so pick a quiet moment. Want to practise first? Run the copy steps once without pausing Vercel, test on your sevalla.app address, then run them again for real.
Your route moves no database or files, so there is no data to freeze and no pause: deploy, check, and point your domain.
Visitors now get a 503 DEPLOYMENT_PAUSED error, and your cron jobs stop writing. Previews, settings and data are unaffected, and you can resume at any time without redeploying.
You need the unpooled connection string, the one Neon recommends for dumps. In Vercel, click Storage and open your Neon database. Find the .env.local snippet on its page, click Show secret, and copy DATABASE_URL_UNPOOLED. (The Neon console's Connect dialog shows the same string when Connection pooling is switched off; the pooled one has -pooler in its host.) Treat it like a password.
Use PostgreSQL command-line tools at the Neon version or newer (for a Neon database on 18, that means 18). Sevalla's Import and export PostgreSQL page says how to get them.
pg_dump "<DATABASE_URL_UNPOOLED>" \
--format=custom --no-owner --no-privileges --exclude-schema=neon_auth --file=vercel.dumpIt prints nothing when it works and leaves a vercel.dump file next to you. neon_auth is the schema Neon Auth creates; leaving it out is harmless if you don't have one. Keep the file until you are sure the move worked.
storefront-db, then the Networking tab.
Your assistant can do this too (toggleDatabaseExternalConnectionV3), but the dump and restore are still yours.
pg_restore --host=storefront-db-k3j4h.ext.sevalla.app --port=20145 \
--username=storefront --dbname=storefront \
--no-owner --no-privileges --jobs=4 vercel.dumpReplace the host, port, user and database with yours. It asks for the password (or set PGPASSWORD first, as Sevalla's import and export page shows). It prints nothing when every object restores. Don't add sslmode=require: in our test the external connection didn't accept it.
Add --clean --if-exists to the command so it replaces the tables from the earlier run. It replaces the data too, so anything you added to the Sevalla database by hand is gone, and the file addresses go back to Vercel's (run again).
SELECT 'your_table' AS "table", count(*) AS "rows" FROM your_table
UNION ALL SELECT 'other_table', count(*) FROM other_table;
-- add one line per table you have
Row counts catch a missing table or a restore that stopped halfway. They don't prove every value is identical; if you want that check, the original guide's step 5 compares a hash of each table. The studio needs a wide browser window: in a narrow one the editor doesn't open.
For example products/coffee-mug-….png. The next step only swaps the domain part of each address.
That is fine for a handful of files. For a store with many files, ask your developer to use the original guide's copy script, which copies every file to the same path in one run (it has a private-store option).
Your database stores the full address Vercel gave each file, on your store's public.blob.vercel-storage.com domain. To find that domain, copy any file's address from Manage Blobs: it is the part before the file's path. Replace it with the bucket's public domain in every column that holds one. The statements below use placeholder table and column names: swap in your own, one statement per column.
UPDATE your_table SET your_column = replace(your_column, 'https://k3j4h5m6n7p8q9r0.public.blob.vercel-storage.com', 'https://storefront-files-x7k2m.sevalla.storage');
UPDATE other_table SET other_column = replace(other_column, 'https://k3j4h5m6n7p8q9r0.public.blob.vercel-storage.com', 'https://storefront-files-x7k2m.sevalla.storage');
The studio only says OK for each statement; it doesn't show how many rows changed. So check with a query. The last column should be 0:
SELECT 'your_table' AS "table", count(*) AS "rows", count(*) FILTER (WHERE your_column LIKE '%vercel-storage%') AS "vercel urls left" FROM your_table
UNION ALL SELECT 'other_table', count(*), count(*) FILTER (WHERE other_column LIKE '%vercel-storage%') FROM other_table;
Ask your assistant for the rest (or do it in the dashboard: Deploy now on the Overview tab):
Red E lines in the build log are normal build output, not errors. The log lists the routes next build prerendered.
Open your app's pages on its sevalla.app address and check them. Vercel is paused now and answers every request with an error, so a side-by-side comparison only works in a practice run, while Vercel is still live. API responses should match what Vercel returned before, except the file addresses, which now point at the bucket. For the example shop:
| Open | You should see |
|---|---|
| Your home page | It loads without errors |
| A page that shows data from your database | The same data you saw on Vercel, with its pictures loading from the bucket |
Each redirect and rewrite you had in vercel.json | The same result as on Vercel (a redirect lands on its target; a rewrite shows the target's content) |
| Your cron route, opened in the browser | A refusal (status 401): the route wants its secret |
Use your own page addresses. Vercel is the reference when it is still serving: open the same page on both and compare.
200 {"ok":true,"run":{"id":2,…}}. A 401 means CRON_SECRET differs from the value your route checks.
Your assistant ran the cron job in the previous step and showed you its log line. A 401 there means CRON_SECRET differs from the value your route checks.
To deploy every push to the branch, click the application's Settings tab, then Update auto-deploy in the Auto-deploy section. Turn on Auto-deploy, choose the Branch, and click Update auto-deploy. While it is on, every push to that branch redeploys the app.
A record to 76.76.21.21, or a CNAME to a vercel-dns address) with the record Sevalla shows: an A record, or a CNAME if your DNS is on Cloudflare. Every A record of the domain must point at Sevalla.http:// to https://.You can't delete the record Vercel creates for the project: add the A record Sevalla shows and it overrides it.
CNAME
The one from . Add it as a DNS only (grey cloud) record until the domain is Active, and set the zone's SSL/TLS mode to Full or Full (strict) before you turn the proxy on.
Before , your domain still points at Vercel. Resume the project from the same Pause Project card in Vercel (the Pause dialog says you can resume at any time without redeploying), fix the problem, and try again. Run the restore with --clean --if-exists and again to start the copy over. Your Sevalla cron job is already scheduled by then; whatever it writes to the Sevalla database is replaced by that restore.
The Troubleshooting button at the top lists the errors we hit, by what you see.
sevalla into your production branch on your Git host (a pull request and Merge), then choose that branch in the application's Auto-deploy settings. Do this only now: the merge removes vercel.json from your production branch, and Vercel still reads it until the project is gone.vercel.dump until you no longer need it.
This route covers the common move. Sevalla's technical guide goes deeper on the rest:
This page is a friendlier version of Migrate from Vercel. When the two differ, check docs.sevalla.com.
Filtered to your route. Type to search.