January 11, 2026 (6mo ago)
Written by Temps Team
Last updated January 11, 2026 (6mo ago)
If you deploy with Vercel, you know the arc: git push, app is live, developer experience is great. Then the invoices arrive — per-seat fees, bandwidth overages, add-on charges for analytics and error tracking. A team of five running three apps can easily cross $300–500/month before adding any observability tooling.
Temps gives you the same git-push workflow with zero per-seat fees, built-in observability, and full control over your infrastructure. Self-host for free (Apache 2.0) or use Temps Cloud at roughly $6/month (Hetzner cost plus 30%, no subscriptions, no bandwidth bills).
TL;DR: Temps is a single Rust binary that replaces six SaaS tools — Vercel for deployments, PostHog/Plausible for analytics, FullStory for session replay, Sentry for error tracking, Pingdom for uptime monitoring, and managed databases.
git pushtriggers Nixpacks auto-detection, Pingora (Cloudflare's proxy, written in Rust) routes traffic, health checks run every 5 seconds with auto-rollback on two consecutive failures, and a WireGuard mesh connects multi-node clusters. No vendor lock-in, no per-seat pricing.
Temps is a self-hosted deployment platform distributed as a single Rust binary. You install it on a VPS (or use Temps Cloud), connect a Git repository, and deploy with git push. Everything else — HTTPS, build detection, health checks, rollbacks, analytics, session replay, error tracking — is included.
It is not a thin wrapper around Kubernetes or Docker Swarm. The proxy layer is Pingora, Cloudflare's battle-tested Rust proxy that handles billions of requests daily. The mesh networking is WireGuard. The build system is Nixpacks, which auto-detects your framework and build commands with no Dockerfile required.
The backend is written entirely in Rust (55 workspace crates, Axum 0.8, Sea-ORM 1.1) and ships as one binary you can install in under five minutes.
| Feature | Temps | Vercel (Pro) | Coolify |
|---|---|---|---|
| Pricing | Free self-host / ~$6/mo Cloud | $20/seat/mo + bandwidth | Free self-host / $5/mo cloud |
| Per-seat fees | None | Yes ($20/seat) | None |
| Built-in analytics | Yes (privacy-first) | Add-on | No |
| Session replay | Yes | No | No |
| Error tracking | Yes (Sentry-compatible) | No | No |
| Uptime monitoring | Yes | No | No |
| Proxy engine | Pingora (Cloudflare) | Proprietary CDN | Traefik / nginx |
| Multi-node WireGuard mesh | Yes | No | No |
| AI Autofixer (error → PR) | Yes | No | No |
| License | Apache 2.0 | Proprietary | Apache 2.0 |
Vercel's pricing scales with your team size; Temps doesn't. Coolify doesn't include analytics, session replay, or error tracking, and has no Pingora proxy or WireGuard mesh.
Citation Capsule: Temps is Apache 2.0, distributed as a single Rust binary, and includes built-in web analytics, session replay, error tracking, uptime monitoring, and managed databases — features that Coolify and Dokploy don't ship. Pricing: free to self-host, or roughly $6/month on Temps Cloud (Hetzner cost plus 30% margin, no per-seat fees, no bandwidth bills).
# Install Temps on a VPS (5-minute setup)
curl -fsSL https://temps.sh/deploy.sh | bash
# Connect your app and deploy
bunx @temps-sdk/cli login https://your-server.example.com
bunx @temps-sdk/cli deploy my-app -b main -e production -y
After that, every git push to main triggers a new deployment automatically. No CI/YAML required — Temps detects your framework via Nixpacks (Next.js, Vite, Django, FastAPI, Go, Rust, Java, and 20+ other languages detected automatically with no Dockerfile needed), builds the image, starts the container, and routes traffic.
Health checks run every 5 seconds. Two consecutive successes confirm a healthy deploy; two consecutive failures within a 60-second error window trigger automatic rollback to the previous known-good version.
Three things set Temps apart from Coolify, Dokploy, and similar tools:
1. Built-in observability stack. Temps ships analytics, session replay, error tracking, and uptime monitoring as first-class features — not optional plugins. You connect your frontend SDK and events flow to your Temps instance, not to PostHog or Sentry. No extra SaaS accounts, no extra billing, no data leaving your infrastructure.
2. Pingora proxy. Cloudflare wrote Pingora in Rust to replace their nginx installation at scale. Temps uses it as the traffic layer — not Traefik, not Caddy, not nginx. Automatic HTTPS via Let's Encrypt is included.
3. WireGuard mesh for multi-node clusters. Add worker nodes with temps join. The control plane uses WireGuard to build an encrypted mesh between nodes, so containers on different servers talk to each other over private addresses without VPN configuration on your end.
Citation Capsule: Temps uses Pingora (Cloudflare's Rust-based proxy, handling billions of requests daily) as its traffic layer, with WireGuard-based encrypted mesh networking for multi-node setups. Health checks run every 5 seconds with automatic rollback triggered by two consecutive failures within a 60-second error window.
Self-hosting is free. The software is Apache 2.0. You pay only for the VPS.
A single Hetzner CX22 (2 vCPU, 4 GB RAM, €4.15/mo as of mid-2026) runs several small production apps comfortably. For teams with more traffic, a CX32 or CX42 handles the load. No per-seat fees as your team grows. No bandwidth billing as your traffic scales.
Temps Cloud provisions Hetzner servers for you and manages setup, SSL, and updates. Pricing is Hetzner cost plus 30% margin — roughly $6/month for an entry-level server. You can migrate off anytime; you own the server.
For comparison: Vercel Pro is $20/seat/month. A team of five pays $100/month in seats alone, before any bandwidth, analytics add-ons, or observability tooling.
Every Temps deployment ships with:
Temps uses Nixpacks for automatic build detection. No Dockerfile needed for any of these:
| Framework / Language | Detection | Notes |
|---|---|---|
| Next.js | package.json + next dep | SSR included, no static export required |
| Vite / React / Vue / Svelte | package.json + framework dep | Served via nginx after build |
| NestJS | package.json + @nestjs/core | Node.js server |
| Angular | angular.json | Static output |
| Astro | package.json + astro dep | Static or SSR |
| Docusaurus | package.json + docusaurus dep | Static site |
| Python (FastAPI, Django, Flask) | requirements.txt / pyproject.toml | ASGI/WSGI server |
| Go | go.mod | Binary build |
| Rust | Cargo.toml | Release build via Nixpacks |
| Java (Maven/Gradle) | pom.xml / build.gradle | JVM app |
| Custom Dockerfile | Dockerfile in root | Full control |
For anything not listed, drop a Dockerfile in the repo root and Temps uses it directly.
Yes. Most standard Next.js, React, and Vue apps require no code changes. The workflow:
bunx @temps-sdk/cli env set)The migration guide walks through the full process including secrets handling, custom domains, and rollback if needed.
Vercel-specific features (Edge Middleware, ISR with Vercel's cache, Vercel KV) require alternative approaches — Temps has its own blob storage, key-value store, and caching layer, but they are different APIs. Most apps don't use those features.
# Self-host on any VPS
curl -fsSL https://temps.sh/deploy.sh | bash
# Or provision Temps Cloud via the dashboard
# https://temps.sh/dashboard
The deploy script handles Docker, TimescaleDB, SSL certificates, GeoLite2 for analytics, and systemd service setup. A fresh install is ready to accept deployments in under five minutes.
Yes. Temps v0.1.0 is in production at multiple teams. The core deployment, proxy, and health-check loop has been in use since v0.0.6. The AI Autofixer is newer (v0.1.0) and should be treated as you would a new tool — run it on a non-critical project first.
Control plane: any Linux VPS with Docker installed, 1 GB RAM minimum (4 GB recommended for production). Workers for additional capacity: Docker required, no minimum beyond what your workloads need. TimescaleDB runs as a Docker container alongside Temps; it's included in the deploy script.
Yes. Every pull request can get its own preview URL. Configure automatic preview deployments in the project settings — Temps creates a new environment per PR and tears it down on merge.
Yes. The Temps MCP server ships 224 tools across 30 categories. AI assistants using Claude, Cursor, or any MCP-compatible client can deploy apps, manage environments, read logs, and query observability data without leaving the chat.
github.com/gotempsh/temps — Apache 2.0. Stars and contributions welcome.