Deploy a TanStack Start application

A TanStack Start application runs on Sevalla as an application: Ingot, Sevalla’s builder, runs vite build from your Git repository, the Nitro plugin turns the build into a Node.js server in .output/, and the web process starts that server on the port that Sevalla sets in the PORT environment variable.

At a glance


Source	A Git repository
Build	Ingot (Node.js 24, npm), or the Dockerfile
Start command	`node .output/server/index.mjs`, which Ingot sets for TanStack Start with Nitro
Port	The `PORT` environment variable, `8080` by default
Processes	Web process
Services	None
Disk	None
Size	H1 for the web process

Environment variables

The application needs no environment variables of its own. Sevalla sets PORT for the web process, and Ingot’s image sets HOST to 0.0.0.0.

Before you begin

A Sevalla company with a payment method, and a GitHub, GitLab or Bitbucket account for the repository. See Git providers.
Node.js 24 or later on your computer.

Create the project

Create a project with the TanStack CLI and its Nitro deployment adapter:

npx @tanstack/cli@latest create storefront --deployment nitro --package-manager npm --no-intent -y
cd storefront

-y accepts the defaults for the other questions, and --no-intent skips the setup for coding agents. The CLI adds the nitro() plugin to vite.config.ts, which makes vite build produce a server that Sevalla can run. The generated file has more plugins and options; the parts that matter look like this:

vite.config.ts

import { defineConfig } from "vite";
import { tanstackStart } from "@tanstack/react-start/plugin/vite";
import viteReact from "@vitejs/plugin-react";
import { nitro } from "nitro/vite";

export default defineConfig({
  plugins: [nitro(), tanstackStart(), viteReact()],
});

For a project created without the adapter, run npm install nitro and add the plugin the same way.

Prepare the project for Sevalla

Pin the Node.js version:

npm pkg set engines.node="24.x"

Without it, Ingot builds on its default line, Node.js 24 today, which a new Ingot release can move. See Pin the Node.js version. Nothing else needs to change, and the project needs no start script. Ingot detects TanStack Start with Nitro, runs the build script (vite build), copies only .output into the image, and starts the web process with node .output/server/index.mjs. The Nitro server takes its port from NITRO_PORT or, when that isn’t set, from PORT, which Sevalla sets to the web process’s port (8080 by default), and Ingot sets HOST to 0.0.0.0, so it listens on all network interfaces. Run npm run build && node .output/server/index.mjs and open http://localhost:3000 to check the production build locally. Then commit everything and push it to your Git provider:

git init
git add .
git commit -m "Prepare for Sevalla"
git branch -M main
git remote add origin https://github.com/acme/storefront.git
git push -u origin main

Deploy to Sevalla

These steps build with Ingot. To build from your own Dockerfile instead, see Deploy with a Dockerfile.

Create the application

In the sidebar, click Applications, then click Create > Application. Under Source, click Private repository, then choose the Git provider, the Repository and the Branch. Under Location, choose a Data center. Keep the Size at H1 or choose a larger one, then click Create application. The application opens on its Overview tab with the status Not deployed yet: creating an application doesn’t deploy it.

Deploy

Click the Overview tab, then click Deploy now under Recent deployments. Check the Branch and click Deploy.

Turn on auto-deploy

To deploy every push to the branch automatically, click the Settings tab, then click Update auto-deploy in the Auto-deploy section. Turn on Auto-deploy and click Update auto-deploy. See Deployments.

Verify the deployment

On the Deployments tab, click the deployment. Its Build log shows Ingot’s build plan: Node.js 24 from engines.node, npm from package-lock.json, TanStack Start with Nitro from package.json, and node .output/server/index.mjs as the start command.

Build log

╭─ ■ TanStack Start (Nitro) · Node.js 24 ─────────────────────────────────────╮
│ Node.js          24                             package.json engines "24.x" │
│ Package manager  npm                            package-lock.json           │
│ Framework        TanStack Start (Nitro)         package.json                │
│ Start            node .output/server/index.mjs  TanStack Start (Nitro)      │
├─ Image ─────────────────────────────────────────────────────────────────────┤
│ Build            node:24-trixie                                             │
│ Runtime          node:24-trixie-slim                                        │
│ User             1000:1000                                                  │
│ Init             tini                                                       │
│ Port             $PORT, default 8080                                        │
╰────────────────────────────────────────────────────────────── Ingot v0.5.0 ─╯

Wait for the deployment’s status to change to Deployed. The application’s status next to its name changes to Running.
Click the domain under the application’s name, for example storefront-x7k2m.sevalla.app. The starter’s home page opens, rendered on the server, with the heading Start simple, ship quickly.

The application header with its name, Running status, repository, branch and the domain that opens the application

To check from a terminal, read the deployment’s status with Get deployment and its build log with Get application deployment logs, as the last steps of Deploy with the API do, then request the domain:

curl -s https://storefront-x7k2m.sevalla.app/ | grep -o 'Start simple, ship quickly.'

Start simple, ship quickly.

If the deployment fails, read its build log, then see Troubleshoot Ingot builds. A build log that shows TanStack Start has no server to run means the project doesn’t have Nitro: run npm install nitro, add nitro() to the plugins in vite.config.ts, then commit and push.

Deploy changes

With Auto-deploy on, every push to the branch starts a deployment; otherwise, click Deploy now for each change. Each deployment builds the image, then replaces the web process’s instances. See Deployments.

Use environment variables

Add configuration on the application’s Environment variables tab. Server functions read variables with process.env when they run. Vite writes variables that start with VITE_ into the client bundle during the build, so keep Available during buildtime selected for them. Variables apply at the next deployment. See Environment variables during the build.

Deploy with a Dockerfile

Ingot needs no Dockerfile. Write one when you want full control of the image: the base image, the system packages and every layer. Add a Dockerfile and a .dockerignore to the root of the repository:

Dockerfile

FROM node:24-trixie AS build
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:24-trixie-slim
WORKDIR /app
ENV NODE_ENV=production PORT=8080
COPY --from=build /app/.output ./.output
USER 1000:1000
EXPOSE 8080
CMD ["node", ".output/server/index.mjs"]

Line or choice	Why
`node:24-trixie`, then `node:24-trixie-slim`	Node.js 24, the line that `engines.node` pins, on Debian 13. The build stage has the compilers that native modules need; the slim final image leaves them out. A line tag picks up Node.js and Debian security fixes at every build, which a digest would stop.
Two stages	The build stage installs every dependency and runs `vite build`. The final image gets only `.output`, where Nitro bundles the server and the dependencies it uses.
The lock file before the source	`npm ci` installs exactly what `package-lock.json` lists, and the build cache reuses that layer until the lock file changes, so a code change doesn’t reinstall the dependencies.
`USER 1000:1000`	The server runs as the image’s `node` user, not as root. Root owns the copied files, so the server can’t change its own code.
`CMD` in exec form	Node.js is the container’s main process and gets `SIGTERM` when an instance stops. Nitro handles it: it finishes the requests in progress for up to 5 s (set `SERVER_SHUTDOWN_TIMEOUT` for longer), then exits.
`PORT=8080`, `EXPOSE 8080`	Nitro listens on `PORT` on all network interfaces. Sevalla sets `PORT` to the web process’s port; `8080` is the default when you run the image yourself.

.dockerignore

.git
.output
.nitro
.tanstack
node_modules
.env*
*.log
Dockerfile
.dockerignore

The .dockerignore keeps local builds, installed packages and local environment files out of the image, so it builds from the committed source only. Sevalla passes build-time environment variables to the build as build arguments: to use a VITE_ variable, declare it with ARG in the build stage, before RUN npm run build. See Use build arguments. Commit and push both files. Ingot doesn’t use the Dockerfile and adds your .dockerignore patterns to its own, so you can keep both files in a repository that builds with Ingot. Then switch the application to the Dockerfile build strategy:

Choose the Dockerfile build strategy

On the application’s Settings tab, in the Build strategy section, click Update build strategy. Click Dockerfile, keep the Dockerfile path Dockerfile and the Docker context ., then click Update build strategy.

Deploy

Click the Overview tab, then click Deploy now under Recent deployments. Check the Branch and click Deploy.

The deployment’s build log shows 📦 Building and pushing docker image using Dockerfile... instead of Ingot’s build plan, and its Dockerfile tab shows your file. When the status changes to Deployed, the application’s domain opens the starter’s home page with the heading Start simple, ship quickly.

Add a custom domain

To serve the application from your own domain, such as shop.example.com, add the domain on the application’s Domains tab and create the DNS records that Sevalla shows. Custom domains need a web process larger than H1, so scale the web process first. See Custom domains.

Connect a database

Create a database in the same location as the application, then connect the application to it with Add environment variables to the application turned on. Sevalla adds DB_URL, DB_HOST, DB_PORT, DB_DATABASE, DB_USERNAME and DB_PASSWORD to the application (what each one holds), and they apply at the next deployment. Read them in server functions with process.env.DB_URL.

Deploy with the API

The Sevalla API makes the same deployment as Deploy to Sevalla without the dashboard. Run the steps in order in one shell: each step is one API call, and saves the IDs that later steps need in shell variables. Each step also names the CLI command and the MCP server tool that do the same. A variable that holds null means the call failed: run the curl command without its jq part to read the error. You need:

An API key with the Company developer role, or the APP:CREATE, APP:READ and APP:UPDATE permissions, in the SEVALLA_API_KEY environment variable. The CLI reads the key from SEVALLA_API_TOKEN.
The repository on GitHub, GitLab or Bitbucket, and a Git account that can read it connected to your Sevalla user, which only the dashboard can do. See Git providers. Creating the application checks the access: if Sevalla can’t read the repository, the call returns 400 with Cannot access repository https://github.com/acme/storefront: Repository not found or you don't have access., followed by where to grant the access.
curl and jq.

Find the location

List clusters (listClustersV3) returns every location with its id, its name in display_name and its region ID in location. Pick one by its region ID, here eu-frankfurt-1 for Frankfurt, Germany. Locations lists them all.

CLUSTER_ID=$(curl -s https://api.sevalla.com/v3/resources/clusters \
  -H "Authorization: Bearer $SEVALLA_API_KEY" \
  | jq -r '.[] | select(.location == "eu-frankfurt-1") | .id')

CLI: sevalla resources clusters. MCP: get_platform_options.

Create the application

Create application (createApplicationV3) creates the application with the Ingot build strategy and a web process, and doesn’t deploy it.

APP_ID=$(curl -s -X POST https://api.sevalla.com/v3/applications \
  -H "Authorization: Bearer $SEVALLA_API_KEY" \
  -H "Content-Type: application/json" \
  -d @- <<EOF | jq -r .id
{
  "display_name": "storefront",
  "cluster_id": "$CLUSTER_ID",
  "source": "privateGit",
  "git_type": "github",
  "repo_url": "https://github.com/acme/storefront",
  "default_branch": "main"
}
EOF
)

CLI:

sevalla apps create --name storefront --cluster "$CLUSTER_ID" --source privateGit --git-type github --repository https://github.com/acme/storefront --branch main

. MCP: create_application with deploy set to false.

Find the web process

List processes (listProcessesV3) returns the web process that Create application added:

WEB_ID=$(curl -s "https://api.sevalla.com/v3/applications/$APP_ID/processes" \
  -H "Authorization: Bearer $SEVALLA_API_KEY" \
  | jq -r '.data[] | select(.type == "web") | .id')

CLI: sevalla apps processes list --app-id "$APP_ID". MCP: get_application, in processes.

Find the H1 size

The API creates the web process with the S1 size, where the dashboard picks H1. List process resource types (listProcessResourceTypesV3) returns the ID of each size:

H1_ID=$(curl -s https://api.sevalla.com/v3/resources/process-resource-types \
  -H "Authorization: Bearer $SEVALLA_API_KEY" \
  | jq -r '.[] | select(.name == "h1") | .id')

CLI: sevalla resources process-types. MCP: get_platform_options.

Set the web process size

Update process (updateProcessV3) sets the size, which applies at the first deployment:

curl -s -X PATCH "https://api.sevalla.com/v3/applications/$APP_ID/processes/$WEB_ID" \
  -H "Authorization: Bearer $SEVALLA_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"resource_type_id\":\"$H1_ID\"}" \
  | jq -r .resource_type_name

h1

CLI: sevalla apps processes update "$WEB_ID" --app-id "$APP_ID" --resource-type "$H1_ID". MCP: scale_process with size_id, and apply_now set to false.

Turn on auto-deploy

Update application (updateApplicationV3) with auto_deploy deploys every push to the branch:

curl -s -X PATCH "https://api.sevalla.com/v3/applications/$APP_ID" \
  -H "Authorization: Bearer $SEVALLA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"auto_deploy":true}' \
  | jq -r .auto_deploy

true

CLI: sevalla apps update "$APP_ID" --data '{"auto_deploy":true}'. MCP: sevalla_api_update with updateApplicationV3, the application ID as path_params.id and the same body.

Choose the Dockerfile build strategy

Skip this step to build with Ingot. To build from the Dockerfile instead, Update application (updateApplicationV3) sets the build strategy:

curl -s -X PATCH "https://api.sevalla.com/v3/applications/$APP_ID" \
  -H "Authorization: Bearer $SEVALLA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"build_type":"dockerfile","dockerfile_path":"Dockerfile","docker_context":"."}' \
  | jq -r .build_type

dockerfile

CLI: sevalla apps update "$APP_ID" --data '{"build_type":"dockerfile","dockerfile_path":"Dockerfile","docker_context":"."}'. MCP: sevalla_api_update with updateApplicationV3 and the same body.

Deploy

Trigger deployment (triggerDeploymentV3) deploys the latest commit of the branch:

DEPLOYMENT_ID=$(curl -s -X POST "https://api.sevalla.com/v3/applications/$APP_ID/deployments" \
  -H "Authorization: Bearer $SEVALLA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{}' \
  | jq -r .id)

CLI: sevalla apps deployments trigger "$APP_ID". MCP: trigger_deployment.

Wait for the deployment

Get deployment (getDeploymentV3) returns the deployment’s status: waiting, inProgress, then success, failed, cancelled or skipped. Poll it until the deployment ends:

for i in $(seq 1 120); do
  STATUS=$(curl -s "https://api.sevalla.com/v3/applications/$APP_ID/deployments/$DEPLOYMENT_ID" \
    -H "Authorization: Bearer $SEVALLA_API_KEY" | jq -r '.status // empty')
  case $STATUS in success|failed|cancelled|skipped) break ;; esac
  sleep 15
done
echo "$STATUS"

success

The loop asks every 15 seconds, for up to 30 minutes, and keeps asking through an empty or failed reply. success means the application is deployed. CLI: sevalla apps deployments get "$DEPLOYMENT_ID" --app-id "$APP_ID". MCP: get_deployment.

Read the build log

Get application deployment logs (getApplicationDeploymentLogsV3) returns the build log, one line per entry. With Ingot, the Start row of the build plan shows the start command:

curl -s "https://api.sevalla.com/v3/applications/$APP_ID/deployments/$DEPLOYMENT_ID/logs?limit=5000" \
  -H "Authorization: Bearer $SEVALLA_API_KEY" \
  | jq -r '.[].message' | grep '│ Start' | tr -s ' '

│ Start node .output/server/index.mjs TanStack Start (Nitro) │

With a Dockerfile, the log shows 📦 Building and pushing docker image using Dockerfile... in place of the build plan. When a deployment fails, the end of this log says why. CLI: sevalla apps deployments logs "$DEPLOYMENT_ID" --app-id "$APP_ID". MCP: get_deployment_logs.

Check the application

List application domains (listApplicationDomainsV3) returns the application’s domains. Request the application on its domain:

DOMAIN=$(curl -s "https://api.sevalla.com/v3/applications/$APP_ID/domains" \
  -H "Authorization: Bearer $SEVALLA_API_KEY" \
  | jq -r '.data[] | select(.is_primary) | .name')
curl -s "https://$DOMAIN/" | grep -o 'Start simple, ship quickly.'

Start simple, ship quickly.

CLI: sevalla apps domains list --app-id "$APP_ID". MCP: get_application, in domains.

Get started

Migrate

AI

JavaScript

Python

PHP

Ruby

Go

Rust

Java, Kotlin and Scala

.NET

Elixir

Gleam

Swift

Dart

Static site generators

Deploy a TanStack Start application

At a glance

Environment variables

Before you begin

Create the project

Prepare the project for Sevalla

Deploy to Sevalla

Verify the deployment

Deploy changes

Use environment variables

Deploy with a Dockerfile

Add a custom domain

Connect a database

Deploy with the API

​At a glance

​Environment variables

​Before you begin

​Create the project

​Prepare the project for Sevalla

​Deploy to Sevalla

​Verify the deployment

​Deploy changes

​Use environment variables

​Deploy with a Dockerfile

​Add a custom domain

​Connect a database

​Deploy with the API

At a glance

Environment variables

Before you begin

Create the project

Prepare the project for Sevalla

Deploy to Sevalla

Verify the deployment

Deploy changes

Use environment variables

Deploy with a Dockerfile

Add a custom domain

Connect a database

Deploy with the API