Tutorial: Deploy an App and Add a Custom Domain

In about 15 minutes you install Temps on a VPS, connect GitHub, deploy a repository, and serve it on your own domain with an automatic Let's Encrypt certificate. This is the long-form version of the Quickstart: it explains what each installer step does, what you see while the app builds, and how to point a custom domain at it. No prior experience with Temps is required.

What you will build

By the end of this tutorial, you will have:

• A running Temps instance on your server
• A Git repository connected to Temps
• A live application deployed from that repository
• Automatic HTTPS via Let's Encrypt
• A custom domain pointing to your app (optional)

Time required: approximately 15 minutes.

What this tutorial covers and does not cover:

Prerequisites

Before you start, make sure you have the following:

Install Temps

SSH into your server, download the Temps installer, and review it before running it:

curl -fsSL https://temps.sh/deploy.sh -o deploy.sh
less deploy.sh
bash deploy.sh

The installer is interactive. First it asks you to pick a setup mode, which decides how the console and your apps are reached:

QuickStart needs no domain, so it is the fastest way through this tutorial; you add your own domain to the app at the end. Choose Advanced if you want the console itself on your domain. You can skip the picker with bash deploy.sh --mode quick (or --mode advanced).

The installer then also asks for your admin email and password (the password defaults to a generated value you can accept) and creates the admin account for you. After that it runs these steps:

1. Docker

The installer checks whether Docker is already present. If not, it installs Docker Engine for you. You do not need to install Docker beforehand.

Checking Docker... Not found.
Installing Docker...
Docker installed successfully (v27.x.x)

2. Database

Temps needs PostgreSQL with the TimescaleDB extension. The installer starts a TimescaleDB container automatically:

The database container listens on port 5432. If that port is already taken (for example by an existing PostgreSQL), the installer picks the next free port between 5433 and 5452. The database password is generated for you.

Later in the run, the installer asks whether to use ClickHouse for proxy logs, analytics, and traces. Running a ClickHouse container on the server is the recommended choice and is pre-selected; you can also point at an existing ClickHouse or keep everything on TimescaleDB. See Migrate Observability to ClickHouse if you want to switch later.

3. Domain and SSL

What happens here depends on the mode you picked. In QuickStart, there is nothing to configure: the installer derives an sslip.io domain from your server's public IP, and certificates are issued automatically the first time each hostname is visited.

In Advanced mode, point your domain at the server first. Not sure of your server's IP? Run this on the server: curl -fsSL https://api.ipify.org; echo

Then create the two A records, replacing YOUR_SERVER_IP with that address:

yourdomain.com  →  A  →  YOUR_SERVER_IP
*.yourdomain.com  →  A  →  YOUR_SERVER_IP

The wildcard record (*) is needed so that each project gets its own subdomain automatically (e.g. my-app.yourdomain.com). The installer then requests a wildcard certificate through a DNS-01 challenge — either a TXT record you paste by hand or automatically through the Cloudflare, Route 53 or DigitalOcean API. If you use Cloudflare, set the wildcard record to DNS only (grey cloud).

4. Temps binary

The installer downloads the newest beta release for your platform (by default; --version <tag> pins one) into ~/.temps/bin/temps and links it to /usr/local/bin/temps:

Installing Temps binary...
Downloading Temps v0.1.0-beta.56...

5. Background service

A systemd service is created so Temps starts automatically on boot and restarts if it crashes:

Created systemd service: temps.service
Temps is running and will start on boot.

6. Verification

The installer confirms the console is reachable and prints a summary. In QuickStart mode it looks like this:

 SETUP COMPLETE
  Your Temps instance is ready!
  Console:         https://console.203-0-113-1.sslip.io
  Apps at:         https://<project>.203-0-113-1.sslip.io
  Admin email:     you@example.com
  Admin password:  ••••••••••••••••
  Domain:          *.203-0-113-1.sslip.io
  Channel:         beta
 ⚠ Save your admin password now — it won't be shown again.

In Advanced mode the console URL is your own domain, e.g. https://yourdomain.com, and the installer also generates an admin API key and prints it in this block.

Log in to the dashboard

Open the URL shown at the end of the installation in your browser.

On your first visit, you will see the login screen. Sign in with the admin email and password from the installer — the installer already created this account, so there is no sign-up step.

After logging in, you will see the Dashboard — a summary of your projects, visitors, and page views. It will be empty since you have not deployed anything yet.

The sidebar on the left gives you access to all platform sections:

• Dashboard — Overview of all projects
• Projects — Create and manage your applications
• Storage — KV and Blob storage
• Domains — Manage custom domains and SSL certificates
• Monitoring — Uptime monitors and alerts
• Email — Transactional email configuration
• Git Providers — Connect GitHub, GitLab, Bitbucket, Gitea, or another git server
• DNS Providers — Configure DNS automation (Cloudflare, etc.)

Connect GitHub

Before you can deploy from a repository, Temps needs access to your GitHub account.

1. In the sidebar, click Git Providers
2. Click Add Git Provider
3. Choose GitHub

You have two connection methods:

After connecting, you should see your provider listed as Active on the Git Providers page. Once it shows Active, continue to Create your first project below.

Create your first project

Now you are ready to deploy an application. In Temps, a project holds your repository settings, its environments and every deployment. There are three ways to create one — click through the dashboard, run the CLI yourself, or hand the steps to your coding agent:

The rest of this section walks the dashboard path in detail.

If you have a repository ready

1. In the sidebar, click Projects
2. Click New Project in the top-right corner
3. Select the GitHub tab. It is named after your Git provider (GitLab, Gitea or Git), or Repositories if you connected more than one
4. Find your repository in the list (use the search bar if needed)
5. Click on it to begin setup

If you need a starter project

If you do not have a repository ready, Temps includes built-in templates:

1. Click New Project
2. On the Template tab, choose one:
   • Next.js SaaS Starter — A full-stack starter with authentication and database
   • Next.js Docs Template — A documentation site with syntax highlighting
3. Click the template card to create a project from it

Configure your project

After selecting a repository or template, Temps asks you to configure the project:

Click Create Project to start the deployment.

Watch it deploy

After creating the project, Temps immediately starts deploying your application. You are taken to the Deployments page where you can watch the process in real-time.

The deployment goes through several stages:

1. Cloning

Temps clones your repository from GitHub. You will see the branch and commit hash:

Cloning repository...
Branch: main
Commit: a1b2c3d "Initial commit"

2. Building

Temps detects your framework and builds a Docker image. For a typical Next.js app, this looks like:

Detected framework: Next.js
Installing dependencies...
Running: npm run build
Build complete (42s)

3. Deploying

The built image is started as a Docker container:

Starting container...
Waiting for health check...
Health check passed

4. Going live

Once the health check passes (two consecutive successful responses, checked every 5 seconds), Temps routes traffic to the new container and provisions an SSL certificate:

Updating routes...
Provisioning SSL certificate...
Deployment complete!

You will see the deployment status change to completed with a green badge on the Deployments page. The deployment entry shows the branch, commit, duration, and a Current label indicating it is the active deployment.

Visit your live app

Your application is now live. You can access it at the URL shown on the project page. Click the Visit button in the top-right corner to open it in a new tab.

Temps automatically assigns a URL based on your project name:

https://my-project.yourdomain.com

If you installed in QuickStart mode, the address uses your server's IP instead:

https://my-project.203-0-113-1.sslip.io

From the project page you can also see:

• Deployment Information — The production and deployment URLs, current status, branch, and commit
• Visitors last 24 hours — A counter that will start populating once you add analytics
• Deployment history — A contribution-graph-style visualization of all deployments over the past year

Add a custom domain

If you want your app to be available at a specific domain like app.yourdomain.com, follow these steps. The Add a custom domain guide covers apex domains, redirects and DNS-01 providers in more depth.

Step 1: Add a DNS record

In your DNS provider (Cloudflare, Namecheap, etc.), create a record pointing to your Temps server:

Or, if you want the root domain:

Wait a few minutes for DNS propagation.

Step 2: Add the domain in Temps

1. Open your project in the dashboard
2. Click Domains in the project sidebar
3. Click Add Domain
4. Enter your domain name (e.g. app.yourdomain.com)
5. Select the SSL challenge type:
   • HTTP-01 (default) — Automatic. Works if port 80 is open on your server.
   • DNS-01 — Required for wildcard certificates. Needs a DNS provider configured (Cloudflare, Route 53, DigitalOcean, Namecheap, GCP or Azure).
6. Click Add

Step 3: Verify and get your certificate

Temps will verify domain ownership and issue an SSL certificate from Let's Encrypt:

Domain: app.yourdomain.com
Status: Verifying...
Status: Certificate issued!

Your app is now available at https://app.yourdomain.com with a valid SSL certificate that renews automatically.

What to explore next

You have a live application running on your own infrastructure. Here is what to do next:

Before real users arrive, work through the production checklist. For other tasks, browse the how-to guides.

Keeping Temps up to date

Until v0.1.0 ships, every Temps release is a prerelease, so a bare temps upgrade (which looks for a stable release) fails with "No stable releases found". Pin the release you want instead:

temps upgrade --version v0.1.0-beta.56

Or follow daily builds with temps upgrade --channel nightly. Always take a backup before upgrading, and check the upgrade guide for what each release changes. Temps starts automatically on server reboot — the systemd service installed during setup handles this.

Got a monorepo?

If your project is inside a larger repository (e.g. apps/web in a monorepo), set the App Directory field in project settings to the subdirectory containing your app. Temps runs the install and build from there, so workspace dependencies and shared packages resolve correctly. Full walkthrough: Deploy a Turborepo monorepo to your own server.

Environments (staging vs production)

Temps supports multiple environments per project — typically production and staging. You can deploy different branches to different environments and keep separate sets of environment variables for each. See Environments for details.