Temps

Temps is a single self-hosted binary that consolidates seven categories of infrastructure SaaS into one platform: Git-push deployments with preview URLs, web analytics with session replay, Sentry-compatible error tracking, OpenTelemetry traces/metrics/logs, uptime monitoring and alerts, transactional email with DKIM, and Firecracker-microVM AI sandboxes with a built-in AI gateway. It installs with a single curl script on a plain Ubuntu VPS and auto-detects the framework of whatever repository you push.

What sets it apart from other self-hosted PaaS options like Coolify or Dokploy is that every one of those subsystems is also exposed as a CLI command — 440+ of them across 69 command groups — and the project ships the agent skills (for Claude Code, Codex, and OpenCode) that teach an AI agent to call them. An agent can deploy a project, inspect a trace, add a custom domain, or rotate a sandbox password without a human opening the dashboard, and Temps can also run those agents itself inside sandboxed workflow VMs with the platform’s own skills and MCP servers pre-injected.

The backend is a ~92-crate Rust workspace built on Axum, Sea-ORM, and Cloudflare’s Pingora proxy engine, backed by PostgreSQL with TimescaleDB for time-series telemetry. The console is a React 19 / TypeScript frontend using shadcn/ui, with its API client generated from the backend’s OpenAPI spec rather than hand-written. Import wizards can migrate an existing Coolify, Dokploy, CapRover, Portainer, Kamal, or Kubernetes setup — including databases with their data — onto Temps directly.

The project is young (first commit October 2025) but growing fast, with an active Rust/TypeScript codebase, dual MIT/Apache-2.0 licensing, and no license-gated features in the self-hosted build. An optional paid Temps Cloud offering exists for teams who don’t want to run the server themselves, but it’s a managed-hosting add-on rather than a feature unlock.

What You Get

• A single-binary self-hosted PaaS installed via curl -fsSL https://temps.sh/deploy.sh | bash, with auto-detected framework builds for Next.js, Vite, Go, Python, Rust, Java, .NET, and NestJS, or your own Dockerfile
• Git push-to-deploy with zero-downtime rollouts and automatic preview URLs for every branch, plus one-click import from Coolify, Dokploy, CapRover, Portainer, Kamal, or Kubernetes — including existing database data
• Built-in web analytics with funnels, visitor tracking, and rrweb-based session replay, none of which leaves your own servers
• Sentry-compatible error tracking — point the official Sentry SDK at a Temps DSN and get error groups, stack traces with source context, and alerts with no code changes beyond initialization
• OpenTelemetry ingestion for distributed traces, metrics, and structured logs in one place, replacing a self-run Grafana/Prometheus/Jaeger/Loki stack
• Uptime monitors, deploy-failure and certificate-expiry alerts, and managed Postgres/Redis/S3(MinIO)/MongoDB provisioning with handled backups
• An OpenAI-compatible AI gateway for bring-your-own-key requests to OpenAI, Anthropic, xAI, or Gemini, with per-model token/latency/cost attribution
• Firecracker-microVM AI sandboxes (Docker backend by default) with a @temps-sdk/sandbox client compatible with @vercel/sandbox’s API shape, including password-protected preview URLs
• 440+ CLI operations across 69 command groups mirroring every dashboard action, plus drop-in agent skills for Claude Code, Codex, and OpenCode

Common Use Cases

• Replacing a Vercel + Sentry + PostHog + Pingdom + Resend stack with one self-hosted server to cut recurring SaaS spend to zero
• Giving an AI coding agent direct, scriptable access to deploy, inspect traces, and manage infrastructure through the CLI instead of a human relaying dashboard actions
• Running untrusted, agent-generated code in hardware-isolated Firecracker microVM sandboxes rather than shared-kernel containers
• Migrating an existing Coolify, Dokploy, or CapRover deployment (apps, databases, domains, and environment variables) onto a single consolidated platform
• Centralizing OpenTelemetry traces, metrics, and logs for a multi-service system without standing up Grafana, Prometheus, Jaeger, and Loki separately
• Adding a Sentry-compatible DSN to an existing app to get error tracking without changing SDK code or paying per-event pricing

Under The Hood

Architecture Temps is a ~92-crate Rust Cargo workspace organized into application crates (temps-cli, which is the single entrypoint binary dispatching to serve, deploy, backup, firecracker, and dozens of other subcommands) and library crates split along service boundaries — temps-deployer for Docker/Traefik-based deployment, temps-proxy fronting Pingora, temps-analytics/temps-analytics-backend/temps-analytics-events for telemetry ingestion, temps-ai/temps-ai-chat/temps-ai-gateway for the AI surface, and temps-cloud/temps-cloud-client for the optional managed offering. The temps serve command in crates/temps-cli/src/commands/serve/ composes the proxy, console, admin gate, and on-demand TLS handling into one process, and design decisions are tracked as numbered ADRs in docs/adr/ (e.g. ADR-041/042 on Cloud-primary telemetry writes) rather than left implicit in code. The workspace explicitly reserves extension points (noted in temps-cli/src/main.rs) for an EE-bundled binary to register additional plugins without forking the OSS dispatch logic, which is a deliberate layering choice rather than an accident of scale.

Tech Stack The backend is Rust on Axum with Sea-ORM for PostgreSQL access (paired with TimescaleDB for time-series telemetry), Pingora (Cloudflare’s Rust proxy engine) for the ingress layer, and Bollard for Docker API control; jemalloc replaces the system allocator specifically to handle the proxy’s allocation pattern. The frontend, in web/, is React 19 and TypeScript built with Rsbuild, styled with Tailwind CSS and shadcn/ui, and its API client (web/src/api/client/) is generated from the backend’s OpenAPI spec via openapi-ts rather than hand-written — the project’s own contributor docs call out a past bug caused by a hand-rolled fetch shim drifting from the real API. CI covers Rust tests, a Bun-based web test suite, Playwright end-to-end tests, and dedicated workflows for container image builds, nightly releases, and sandbox images.

Code Quality Test directories exist across more than a dozen crates (temps-core, temps-git, temps-domains, temps-dns, temps-metrics, temps-observability, and others), and the CI pipeline runs cargo-audit against the RustSec advisory database, bun audit for web dependencies, and a scheduled Trivy container scan against published release images — supply-chain scanning that goes beyond typical self-hosted-PaaS projects. Every first-party source file is required to carry an SPDX attribution header, enforced by a repository-wide check script (scripts/source_attribution.py check) that blocks non-compliant commits, and CHANGELOG.md is generated from Conventional Commits via git-cliff rather than hand-edited, with a CI job that validates every commit message in a PR. A DCO workflow enforces signed-off commits, and error handling in the core crate uses typed thiserror enums (ServiceError in temps-core/src/error.rs) rather than string-based or swallowed errors.

What Makes It Unique Most self-hosted PaaS projects (Coolify, Dokploy, CapRover) stop at git-push deployment; Temps additionally bundles web analytics with session replay, Sentry-wire-compatible error tracking, full OpenTelemetry ingestion, uptime monitoring, transactional email, and an AI gateway into the same binary, explicitly positioning itself against seven separate SaaS categories at once. Its more distinctive choice is exposing all of that — 440+ operations across 69 CLI command groups — as agent-drivable surface area, shipping the actual Claude Code/Codex/OpenCode skill files in the repository (skills/) so an AI agent can deploy, inspect traces, or rotate a sandbox password without a human in the loop, and running Firecracker microVMs (the same isolation technology behind AWS Lambda) for executing agent-generated code with a real kernel boundary rather than a shared-kernel container.

Self-Hosting

Licensing Model Dual-licensed under MIT OR Apache-2.0 (your choice) — a fully permissive license with no license keys, feature flags, or paid-tier gates in the self-hosted binary. Forks and rebranded or commercial redistributions are explicitly permitted, provided copyright and attribution notices are preserved.

Self-Hosting Restrictions None found. The README, source, and CLI show no feature that requires a license key or paid plan to run self-hosted — deployments, analytics, session replay, error tracking, OpenTelemetry, uptime monitoring, managed databases, transactional email, the AI gateway, and Firecracker sandboxes are all available in the open-source build.

Enterprise Features The codebase reserves extension points for “EE-bundled binaries” (referenced in crates/temps-cli/src/main.rs and internal ADRs) that could register additional plugins, but no separate enterprise edition or feature list is published in this repository as of this analysis.

Cloud vs Self-Hosted Temps Cloud is an optional managed-hosting offering (“at cost + 30%”, per the project’s own skill documentation) for teams who don’t want to run their own server. It is a hosting convenience, not a feature unlock — the self-hosted binary has the same feature set. Temps Cloud also offers a cloud-primary telemetry storage mode as an add-on for teams that don’t want to retain OpenTelemetry history locally.

License Key Required No.