Introducing Temps: A Self-Hosted Vercel Alternative

If you deploy with Vercel, you know the arc: git push, the app is live, the developer experience is great. Then the invoices arrive. Vercel Pro is a $20/month platform fee that includes one deploying seat, and every extra deploying seat is another $20, so five developers pay about $100/month before data transfer overage, add-ons, or the analytics, error tracking and session replay tools Vercel doesn't include.

Temps is our answer: one self-hosted platform that bundles git-push deployment with analytics, session replay, error tracking and uptime monitoring, instead of a deployment tool plus three separate SaaS accounts. You keep the git-push workflow, pay no per-seat fees, and own the infrastructure. Self-hosting is free (MIT / Apache 2.0); the cost is the server you run it on. Temps Cloud, a hosted control plane for your own servers, is coming soon from $29/month. For a head-to-head on features and cost, see Temps vs Vercel.

TL;DR: Temps is one self-hosted platform that replaces seven SaaS tools: Vercel (git-push deployments), PostHog (analytics and session replay), Sentry (error tracking), Pingdom (uptime monitoring), Datadog (OpenTelemetry traces, metrics and logs), Resend (transactional email) and E2B (AI agent sandboxes). On git push, Temps detects common frameworks from your repository files (Next.js, Vite, Python, Go, Rust, Java and more) or builds your Dockerfile. Pingora, Cloudflare's Rust proxy framework, routes traffic. A new deployment only takes traffic after it passes its health check, and a WireGuard mesh connects multi-node clusters. No per-seat pricing.

What is Temps?

Temps is a self-hosted deployment platform written in Rust. You install it on a server, connect a Git repository, and deploy with git push. HTTPS, build detection, health-checked deployments, rollbacks, analytics, session replay and error tracking are all included.

It is not a thin wrapper around Kubernetes or Docker Swarm. The proxy layer is Pingora, the Rust proxy framework Cloudflare built to replace nginx in its own network. Multi-node networking runs over WireGuard. Builds use Temps' own presets, which detect the framework from your repository files, and any repository with a Dockerfile builds from it.

Is it ready for production? Temps is in its v0.1.0 beta series (v0.1.0-beta.56, released 2026-08-21; v0.1.0 GA has not shipped). The parts that keep an app online, which are deployments, the proxy, domains, environment variables, managed services, backups, logs and uptime monitoring, are labelled Stable in Temps' feature maturity registry. Analytics, session replay and error tracking are labelled Beta, and the AI features are Experimental, so start those on a non-critical project. If your bar for production is a decade of track record, Dokku (since 2013) or Coolify have more of it, without the observability Temps includes.

How does Temps compare to Vercel, Coolify, Dokploy, and Dokku?

Vercel's pricing scales with your team size; Temps doesn't. Coolify, Dokploy and Dokku are deployment-first tools: Coolify added opt-in traffic analytics in v4.4 (October 2026), but none of the three ships error tracking, session replay or uptime checks, so running any of them in production still means adding Sentry, a replay tool and an uptime service. Dokploy also keeps SSO, SCIM, audit logs and fine-grained RBAC behind an Enterprise licence, even when self-hosted. Temps is newer than Dokku or Coolify, which is also why it was built around a bundled observability stack the older tools were never designed for.

What does the deployment workflow look like?

# On your server: install Temps
curl -fsSL https://temps.sh/deploy.sh | bash

# From your machine: log in 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. No CI YAML is required: Temps detects your framework, builds the image, starts the container and routes traffic.

Before traffic moves to the new deployment, Temps probes it every 5 seconds and needs 2 consecutive successful responses. If the app isn't healthy within the startup timeout (5 minutes by default), the deployment is marked failed and the previous one keeps serving. Temps doesn't roll back automatically after a deployment has gone live; you roll back by redeploying a previous deployment.

What makes Temps different from other self-hosted platforms?

Three things set Temps apart from Coolify, Dokploy and similar tools:

1. Built-in observability. Analytics, session replay, error tracking and uptime monitoring are part of the platform, not plugins. You add the SDK to your frontend and events flow to your Temps instance, not to PostHog or Sentry. No extra SaaS accounts, no extra billing, and the data stays on your servers.

2. Pingora proxy. Temps uses Pingora as the traffic layer instead of Traefik, Caddy or nginx, with automatic HTTPS through Let's Encrypt.

3. WireGuard mesh for multi-node clusters. Add worker nodes with temps join. The control plane builds an encrypted WireGuard mesh between nodes, so containers on different servers reach each other over private addresses without VPN setup on your side.

How much does self-hosting Temps cost?

Self-hosting is free. The software is MIT / Apache 2.0; you pay for the server.

A Hetzner CX23 (2 shared vCPU, 4 GB RAM, 40 GB NVMe) is €5.49/month excluding VAT and meets Temps' minimum of 2 CPU cores and 4 GB RAM. A CX33 (4 vCPU, 8 GB RAM) is €8.49/month excluding VAT and leaves more room for several apps and managed databases (both verified 2026-10-07). There are no per-seat fees as your team grows and no bandwidth billing from Temps as traffic grows.

Temps Cloud is a coming-soon hosted control plane for your own servers: Temps hosts the console, deploys, error tracking, analytics, backups and history, while your apps, databases and traffic stay on servers you connect. It isn't VPS hosting, so you still pay your hosting provider separately. Plans start at $29/month. Until it ships, you run Temps on whatever server you choose.

For comparison, a 5-developer team on Vercel Pro pays $100/month in platform and seat fees alone, before overage, add-ons or observability tooling. See Vercel pricing 2026 for worked bills.

What observability features are included?

Every Temps deployment can use:

• Web analytics: pageviews, unique visitors, custom events and geographic breakdown, identified with two first-party cookies set by the Temps proxy and never shared with a third party.
• Session replay: off by default; when enabled it records the page and user input, with every input masked, so you can see what happened before an error. The recordings stay on your server.
• Error tracking: a Sentry-compatible DSN. Keep your existing Sentry SDK and point it at your Temps DSN.
• Uptime monitoring: scheduled checks with alerts by email, Slack or webhook.
• OpenTelemetry tracing: OTLP ingest for traces, metrics and logs, queryable in the Observe dashboard.
• AI Autofixer (experimental): from an error group, an agent reads the stack trace, works on your repository in a sandbox and opens a pull request with a proposed fix after you approve its analysis.

What frameworks and languages does Temps support?

Temps detects these from your repository files, with no Dockerfile needed:

Others need you to pick a preset: Express, NestJS, Astro, Nuxt and Remix use the Node.js preset, Create React App uses the react-app preset, Laravel and Rails have their own presets, and Remix or SvelteKit apps that need server rendering should switch from the detected Vite preset to the Node.js one. The full list is in supported platforms. A Dockerfile in the repository always works.

Can I migrate from Vercel to Temps?

Yes. Most standard Next.js, React and Vue apps need no code changes. The workflow:

1. Install Temps on a server.
2. Connect your GitHub repository so pushes deploy automatically.
3. Set your environment variables in the dashboard or with bunx @temps-sdk/cli environments vars set.
4. Add your custom domain; Temps shows the DNS records and issues a Let's Encrypt certificate.
5. Verify the deployment, lower your DNS TTL and cut over.

The Vercel migration guide covers the full process, including secrets, custom domains and how to go back if needed. For the decision itself (when to move, where, and what it costs), see migrating from Vercel to self-hosted.

What actually causes migration friction?

For most standard apps the friction is lower than teams expect, but three areas are worth checking before you cut over:

• Vercel-specific middleware APIs. Standard Next.js middleware runs under next start on Temps. Code that relies on Vercel-only request data or packages, such as Vercel's geolocation headers, needs another source.
• ISR caching. On Vercel, ISR output is cached on Vercel's CDN. On Temps, revalidation still works, but the cache lives with your app on your server, and a global cache needs a CDN in front.
• Vercel KV, Postgres and Blob. Vercel KV and Postgres moved to Upstash and Neon in December 2024; Blob is Vercel's. Temps offers managed Redis, Postgres and S3-compatible storage that you reach through standard connection strings and clients, which is usually a small code change, not a rewrite.

None of these block a migration; they are the checklist that turns "should work" into "verified working" before you switch DNS. If anything doesn't check out, point DNS back to Vercel.

Getting started

# Self-host on your own server (needs bash; installs Docker if missing)
curl -fsSL https://temps.sh/deploy.sh | bash

The installer sets up Docker, TimescaleDB, TLS certificates and the Temps service, and creates the first admin account. Temps Cloud, for connecting your own servers to a hosted control plane, is coming soon.

• Quickstart guide
• Deploy Next.js to your own server
• Migrate from Vercel to self-hosted
• Temps vs Coolify (detailed comparison)

FAQ

Is Temps a good Vercel alternative for production?

For teams that want to self-host, yes. Temps bundles the git-push deployment workflow with web analytics, session replay, error tracking and uptime monitoring, so self-hosting in production doesn't mean assembling a deployment tool plus three SaaS accounts. Deployments, the proxy and uptime monitoring are labelled Stable; the observability features are Beta. Self-hosting is free under MIT / Apache 2.0. If you need a decade-long track record or a large catalogue of one-click templates more than bundled observability, evaluate Dokku or Coolify alongside it. The Temps vs Vercel comparison covers the trade-offs.

Is Temps production-ready?

The core is: deployments, the proxy, domains, managed services, backups and uptime monitoring are labelled Stable in the v0.1.0 beta series (v0.1.0-beta.56 as of 2026-08-21; GA has not shipped). Analytics, session replay and error tracking are Beta, and the AI features, including the Autofixer, are Experimental. Try those on a non-critical project first.

What are the infrastructure requirements?

A Linux server with at least 2 CPU cores and 4 GB of RAM. The installer installs Docker if it isn't present and runs TimescaleDB in Docker alongside Temps. Worker nodes for extra capacity need Docker and whatever your workloads require.

Does Temps support preview environments?

Yes. Each branch, or each pull request, can get its own preview environment with its own URL. Pushing the branch again redeploys the same environment, and the environment is soft-deleted when its branch is removed.

Does Temps have an MCP server?

Not in the current release. The standalone @temps-sdk/mcp package was removed in July 2026. A built-in MCP server has landed on the main branch, off by default, but it isn't in v0.1.0-beta.56. Today AI agents operate Temps through the Temps agent skills and the CLI (bunx @temps-sdk/cli), which cover deploys, environments, logs and observability queries.

Where is the source code?

github.com/gotempsh/temps, MIT / Apache 2.0, public since October 2025. The observability stack is in the open-source repository. Enterprise features such as SAML SSO, SCIM and the tamper-evident audit log are part of Premium, a $399/month licence per organisation.

What are the honest downsides compared to Coolify or Dokku?

Temps is newer: its repository went public in late 2025 and it is still in the v0.1.0 beta series, while Dokku has been running since 2013 and Coolify has about 62,700 GitHub stars (October 2026) and a v4 line that went stable in April 2026. That means a smaller community and plugin ecosystem than either. Temps has no edge functions, and it doesn't claim SOC 2 or HIPAA compliance (Vercel publishes a SOC 2 Type 2 report and offers a HIPAA BAA as a paid add-on). Temps is younger because it was built around a bundled deployment-plus-observability model the older, deployment-only tools weren't designed for. If you need edge functions or formal compliance certifications today, weigh that against the SaaS bills Temps removes.