Deploy a Fresh application

A Fresh application runs on Sevalla as a Deno application: Ingot, Sevalla’s builder, detects deno.json in your Git repository, installs the dependencies from deno.lock, runs the build task, which writes the production build to _fresh/, and the web process runs the start task, deno serve -A _fresh/server.js, on the port that Sevalla sets in the PORT environment variable.

At a glance


Source	A Git repository
Build	Ingot (Deno 2.9), or the Dockerfile
Start command	`deno serve -A _fresh/server.js`, from `tasks.start` in `deno.json`
Port	The `PORT` environment variable, `8080` by default, which Ingot passes to `deno serve` in `DENO_SERVE_ADDRESS`
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.

Before you begin

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

Create the project

Create a Fresh 2 project. The flags answer the questions the script would ask: no Tailwind CSS and no VS Code settings.

deno run -Ar jsr:@fresh/init storefront --tailwind=false --vscode=false
cd storefront

The script writes a Fresh 2.3 project that builds with Vite, installs its dependencies into node_modules/ and writes deno.lock. Its deno.json has the tasks Sevalla uses:

Task	Command	What it does
`build`	`vite build`	Writes the server and the browser assets to `_fresh/`
`start`	`deno serve -A _fresh/server.js`	Serves the build
`dev`	`vite`	Runs the development server with hot reload

The template’s .gitignore already keeps _fresh/ and node_modules/ out of the repository.

Prepare the project for Sevalla

Pin the Deno version:

echo "2" > .dvmrc

File	Why Sevalla needs it
`.dvmrc`	Ingot, the default build strategy, builds on the newest Deno 2 line it knows: Deno 2.9 in Ingot 0.4.1. Without a version, Ingot uses its default line, which a new Ingot release can move.
`deno.lock`	Ingot installs the exact versions in it with `deno install --frozen`, which fails instead of changing them. Commit it.
`deno.json`	Ingot detects Deno from it, runs the `build` task during the build, and starts the web process with `deno task start`.

Ingot needs no other configuration. Before the server starts, Ingot sets DENO_SERVE_ADDRESS from PORT, which Sevalla sets to the web process’s port (8080 by default), so deno serve listens on that port on all network interfaces. When Sevalla stops an instance, deno serve gets SIGTERM, finishes the requests in progress, then exits. See How processes run. Run deno task dev and open the address it prints to check the project 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: Deno 2.9 for the 2 in .dvmrc, and the start and build tasks from deno.json.

Build log

╭─ ■ Deno 2.9 application ───────────────────────────────────────╮
│ Deno     2.9                             .dvmrc "2"            │
│ Start    deno serve -A _fresh/server.js  deno.json tasks.start │
│ Build    vite build                      deno.json tasks.build │
├─ Image ────────────────────────────────────────────────────────┤
│ Build    denoland/deno:debian-2.9.8                            │
│ Runtime  denoland/deno:debian-2.9.8                            │
│ User     1000:1000                                             │
│ Init     tini                                                  │
│ Port     $PORT, default 8080                                   │
╰───────────────────────────────────────────────── Ingot v0.4.1 ─╯

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 page shows Welcome to Fresh. Add /api/joe to the address: it returns Hello, Joe!.

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 'Welcome to Fresh'
curl -s https://storefront-x7k2m.sevalla.app/api/joe

Welcome to Fresh
Hello, Joe!

If the deployment fails, read its build log, then see Troubleshoot Ingot builds. For a server that runs Deno.serve() without Fresh, see Deploy a Deno application.

Deploy with a Dockerfile

Ingot needs no Dockerfile. Write your own 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 denoland/deno:debian-2.9.8 AS build
WORKDIR /app
COPY deno.json deno.lock ./
RUN deno install --frozen
COPY . .
RUN deno task build

FROM denoland/deno:debian-2.9.8
WORKDIR /app
ENV DENO_NO_UPDATE_CHECK=1
COPY --from=build /app/_fresh ./_fresh
USER 1993:1993
EXPOSE 8080
CMD ["sh", "-c", "exec deno serve --allow-net --allow-env --allow-read --port ${PORT:-8080} _fresh/server.js"]

Line or choice	Why
`denoland/deno:debian-2.9.8`	Deno’s official image on Debian 13, the image Ingot builds Deno 2.9 on. Deno publishes images per release, with no tag that follows a line, so update the tag when you move to a new Deno release.
Two stages	The `build` stage installs the dependencies, including Vite, and runs `vite build`. `_fresh/server.js` bundles the server code it needs, so the final stage copies only `_fresh/`, without `node_modules` or the source.
`deno.json` and `deno.lock` copied before the source	A change to your code reuses the cached `deno install` layer.
`--allow-net --allow-env --allow-read`	Grants `deno serve` only what the server uses, instead of the `-A` of the `start` task. Add a permission if your code needs one, such as `--allow-write`.
`${PORT:-8080}`	The shell reads `PORT`, which Sevalla sets, and `exec` replaces the shell with Deno. The image’s own entrypoint runs `tini`, which passes `SIGTERM` on to Deno.
`USER 1993:1993`	The image’s `deno` user, not root. The copied files stay owned by root, so the server can read its code but not change it.
`DENO_NO_UPDATE_CHECK=1`	Stops Deno from checking for a newer release when it starts.

.dockerignore

.git
node_modules
_fresh
.env*
*.log
Dockerfile
.dockerignore

Commit and push both files. Ingot doesn’t use the Dockerfile, so you can keep it in a repository that builds with Ingot, but it adds the .dockerignore patterns to its own: its build plan then shows Ignored 7 patterns from .dockerignore, and the Ingot build still passes because none of these patterns removes a file it needs. 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 deployment’s status is Deployed, the domain shows Welcome to Fresh again. See Dockerfile.

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 and read it in server code with Deno.env.get(). Variables marked Available during buildtime also reach deno install and vite build with Ingot; with a Dockerfile, they arrive as build arguments, which a stage reads only after an ARG line for each one. Variables apply at the next deployment. See Environment variables.

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.

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 deno serve -A _fresh/server.js deno.json tasks.start │

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 'Welcome to Fresh'
curl -s "https://$DOMAIN/api/joe"

Welcome to Fresh
Hello, Joe!

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 and Kotlin

.NET

Elixir

Static site generators

Deploy a Fresh application

At a glance

Environment variables

Before you begin

Create the project

Prepare the project for Sevalla

Deploy to Sevalla

Verify the deployment

Deploy with a Dockerfile

Deploy changes

Use environment variables

Add a custom domain

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 with a Dockerfile

​Deploy changes

​Use environment variables

​Add a custom domain

​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 with a Dockerfile

Deploy changes

Use environment variables

Add a custom domain

Deploy with the API