Deployment Pipeline

Push to your branch and Temps takes it from there — cloning the repository, building a Docker image with Nixpacks, starting the container, and routing traffic only after health checks pass. This page explains every step of the pipeline and what you can control.

What happens when you deploy

Loading diagram...

Step 1: Connect your repository

Temps clones your linked GitHub, GitLab, or other Git repository when a deployment is triggered. It inspects the source tree to detect your language and framework automatically, so you do not need to specify them in advance.

Step 2: Build your application

If your repository includes a Dockerfile, Temps uses it directly — supporting all Docker features and build arguments with layer caching for faster rebuilds. If there is no Dockerfile, Temps detects your language and generates one automatically using Nixpacks. This covers Node.js, Python, Rust, Go, Java, Ruby, PHP, and more with zero configuration.

Step 3: Configure environment

Environment variables are injected into the container at runtime. Secrets are stored encrypted and are never written to the image. You can define variables at the project level (shared across all environments) or at the environment level (scoped to dev, staging, or production). Managed database credentials are injected automatically when you attach a database.

Step 4: Deploy container

Temps starts the container with your configured environment variables and resource limits. Health checks run against your configured endpoint to confirm the application is responsive before traffic is routed. If the container fails to start, Temps retries automatically and records the failure in deployment logs.

Step 5: Set up domain and SSL

Temps assigns your app a custom domain or an auto-generated subdomain, then requests a TLS certificate from Let's Encrypt. Certificates renew automatically before expiry. Your app is live and served over HTTPS from the moment the health check passes.

What you can control

Build configuration

Use your Dockerfile — full control with a custom Dockerfile in your repository
Auto-detection — let Temps detect the language and generate a Dockerfile via Nixpacks
Build arguments — pass custom build-time variables in the deployment settings
Build logs — watch exactly what happens during the build in real-time

Environment variables

Project-level — variables shared across all environments
Environment-level — variables scoped to dev, staging, or production
Secrets — encrypted storage for passwords and API keys
Override — override variables for a specific deployment without changing the defaults

Resource limits

Memory — set how much RAM your app can use
CPU — limit CPU usage to prevent resource contention
Disk — storage limits for container volumes
Timeouts — request timeout settings for the upstream proxy

Deployment settings

Port configuration — which port your app listens on
Health check path — custom health check endpoint (defaults to /)
Restart policy — automatic restarts on failure
Rollback — instantly revert to a previous deployment

Deployment states

Your deployment goes through these states:

Loading diagram...

PENDING - Deployment queued BUILDING - Building your container BUILT - Container image created DEPLOYING - Starting the container RUNNING - Container is running ACTIVE - Receiving live traffic

If something goes wrong, the state becomes FAILED and the deployment detail page shows error details.