Coolify self-hosted is free (Apache 2.0); Cloud is $5/mo for 2 servers — but it is deployment-only. Full cost with observability vs Temps, the only self-hosted PaaS bundling deployment, analytics, error tracking, session replay, and uptime monitoring at ~$6/mo.
Temps Team
May 26, 2026 · 2mo ago · updated July 23, 2026
Coolify pricing in 2026: Self-hosted Coolify is free forever under the Apache 2.0 license — no feature limits, no user caps, no trial period. Coolify Cloud costs $5/month for 2 connected servers ($3/month per additional server), with a 20% annual discount (~$4/month). Each additional team requires a separate $5/month subscription.
| Plan | Price | What's included |
|---|---|---|
| Self-hosted | $0 | Full product, Apache 2.0, unlimited servers, unlimited users |
| Cloud (monthly) | $5/mo | 2 connected servers, managed control plane, email alerts |
| Cloud (annual) | ~$4/mo | Same as monthly, 20% discount |
| Extra servers | +$3/mo each | Added to any Cloud subscription |
| Extra teams | +$5/mo each | Each additional team = separate subscription |
Quick answer: Coolify self-hosted = $0 software +
$5–10/mo VPS. Coolify Cloud = $5/mo control plane + your VPS cost ($10/mo minimum total). Self-hosting stays free regardless of team size or server count.
Is there a self-hosted PaaS that costs less than Coolify once you add observability? Temps is a self-hosted PaaS that bundles deployment, web analytics, session replay, a Sentry-compatible error-tracking DSN, and uptime monitoring into a single Rust binary — the only self-hosted PaaS that ships all five in one install. Coolify, Dokploy, and Dokku are deployment-only, so matching that stack means bolting on separate SaaS tools. Temps Cloud costs ~$6/mo (Hetzner cost + 30%, no per-seat fees). Self-hosted Temps is free under Apache 2.0.
Related: Full Coolify review 2026 · 5 best Coolify alternatives
Yes. Self-hosted Coolify is free forever. There are no feature gates, no user limits, no trial periods, and no premium tiers hidden behind a paywall. The full product — all 280+ one-click templates, unlimited servers, unlimited deployments, unlimited team members — is available at no cost under the Apache 2.0 license.
Your only cost is the infrastructure you run it on:
| Item | Cost |
|---|---|
| Coolify software license | $0 (Apache 2.0) |
| VPS for Coolify control plane | ~$5/mo |
| VPS for your applications | ~$5–20/mo per server |
| Total minimum | ~$10–25/mo |
Coolify's official documentation recommends running the Coolify management layer on a dedicated server separate from your workloads. That means budgeting for at least two VPS instances — one for Coolify itself and one for your apps.
Citation Capsule: Coolify's self-hosted pricing is confirmed as "Free Forever" with "no limitation or restrictions" on the official Coolify pricing page (Coollabs, verified July 2026).
Coolify Cloud is the managed option where Coollabs hosts and maintains your Coolify instance. You still bring your own VPS — Cloud manages the dashboard and control plane, not your application workloads.
| Plan | Price | Servers Included | Extra Servers |
|---|---|---|---|
| Cloud (monthly) | $5/mo | 2 | +$3/mo each |
| Cloud (annual) | ~$4/mo (save 20%) | 2 | +$3/mo each |
Cloud does not host your applications. You supply servers from Hetzner, DigitalOcean, AWS, or any provider. Coolify Cloud manages the control plane that coordinates those servers.
Realistic total cost for a two-server Cloud setup:
| Component | Monthly |
|---|---|
| Coolify Cloud base (2 servers) | $5 |
| 2x Hetzner CX22 VPS (~EUR 4.85 each) | ~$10 |
| Subtotal — deployment only | ~$15 |
That $15 covers deployments and managed databases. It does not include web analytics, error tracking, session replay, or uptime monitoring. Those tools add $254+/mo if sourced from separate SaaS vendors (Sentry $26 + Plausible $9 + FullStory $199+ + Better Uptime $20).
Citation Capsule: Coolify Cloud pricing is $5/month for 2 servers + $3/month per additional server, with 20% annual discount. Source: coolify.io/pricing, verified July 2026.
Coolify uses the Apache License 2.0 — one of the most permissive open-source licenses:
| Use case | Permitted? |
|---|---|
| Personal projects | Yes |
| Commercial SaaS products | Yes |
| Internal company tooling | Yes |
| Modify and redistribute | Yes (with attribution) |
| Use in proprietary software | Yes |
| Build a managed service on top of Coolify | Yes |
Apache 2.0 requires you to retain the original copyright notice and license text if you distribute the software. It does not require you to open-source your own applications that run on Coolify infrastructure.
This is a meaningful distinction from licenses like AGPL or SSPL (used by MongoDB and Elastic), which require you to publish source code if you modify and serve the software as a network service. Coolify's Apache 2.0 has no such network-use provision.
Citation Capsule: Coolify is licensed under Apache License 2.0, verified at the Coolify GitHub repository. The license permits commercial use, modification, and proprietary applications without copyleft obligations.
Coolify supports multiple teams in both self-hosted and Cloud versions. The pricing model differs significantly:
Self-hosted teams: Unlimited teams, unlimited members, at no additional cost. You can create separate teams per client or project, each with distinct server access and permissions, all within a single Coolify instance.
Cloud teams: Each additional team requires a separate Cloud subscription. If you manage a primary organization plus three client workspaces, you need four subscriptions ($5/mo each = $20/mo minimum).
| Setup | Self-hosted cost | Cloud cost |
|---|---|---|
| 1 team, any members | $0 software | $5/mo |
| 3 teams, any members | $0 software | $15/mo |
| 5 teams, any members | $0 software | ~$25/mo |
For freelancers and agencies managing multiple client environments, this per-team model makes Cloud costs multiply quickly. Self-hosting sidesteps it entirely.
Coolify handles deployments and managed databases excellently. It does not include web analytics, error tracking, session replay, or uptime monitoring. For a production application that needs all of these, the cost picture changes significantly.
| Tool | Purpose | Monthly cost |
|---|---|---|
| Plausible Cloud | Web analytics | $9/mo |
| Sentry Team | Error tracking | $26/mo |
| FullStory | Session replay | $199+/mo |
| Better Uptime | Uptime monitoring | $20/mo |
| Observability subtotal | $254+/mo |
| Scenario | Coolify Cloud + observability | Temps Cloud |
|---|---|---|
| Deployment only | ~$15/mo | ~$6/mo |
| With full observability | ~$269/mo | ~$6/mo |
| Solo developer | ~$259/mo | ~$10/mo |
| 5-person startup | ~$269/mo | ~$25/mo |
The "full observability" row: Coolify Cloud $15 + Sentry $26 + Plausible $9 + FullStory $199+ + Better Uptime $20 = $269/mo. Temps includes analytics, error tracking, session replay, and uptime monitoring built into the same binary.
"Every Temps deployment includes PostHog-equivalent analytics, Sentry-equivalent error tracking, FullStory-equivalent session replay, and built-in uptime monitoring — at ~$6/mo on Hetzner, versus $269/mo for the equivalent Coolify + SaaS observability stack."
Coolify v4.0.0 went stable on April 27, 2026, after nearly two years of beta. The latest stable release is v4.1.2 (June 2026) — see the Coolify releases page for the current tag. v4.1.0 (May 2026) added Railpack builds, audit logging, and MCP support.
The v4 series is a complete rewrite from Coolify v3:
Coolify has over 59,300 GitHub stars as of July 2026, making it the most-starred self-hosted PaaS on GitHub.
Coolify announced a v5 rewrite focused on multi-server scalability. As of July 2026, the v5 milestone on GitHub has its first issues assigned but no release date or public timeline. The v4 stable series continues shipping actively. There is no announced migration path from v4 to v5 yet.
All three platforms are open-source with self-hosting available. The cost differences surface when you account for everything a production app needs — not just deployment, but also observability.
| Coolify | Dokploy | Temps | |
|---|---|---|---|
| Self-host license | Free (Apache 2.0) | Free (Apache-2.0 base, source-available — some advanced features restricted) | Free (Apache 2.0) |
| Cloud managed tier | $5/mo | See pricing page | ~$6/mo |
| Built-in analytics | No | No | Yes |
| Built-in error tracking | No | No | Yes |
| Built-in session replay | No | No | Yes |
| Built-in uptime monitoring | No | No | Yes |
| Deployment cost (Cloud) | ~$15/mo | ~$10/mo | ~$6/mo |
| Total with full observability (Cloud) | ~$269/mo | ~$264/mo | ~$6/mo |
The "total with full observability" row: Coolify Cloud $15 + observability $254 = $269/mo. Dokploy estimate ~$10/mo VPS + $254 observability = $264/mo. Observability = Sentry ($26/mo) + Plausible ($9/mo) + FullStory ($199+/mo) + Better Uptime ($20/mo) = $254/mo. Temps includes all four in a single binary.
Related: 5 best Coolify alternatives (2026) · How to migrate from Coolify to Temps
For teams that need deployment plus production observability, Temps is the stronger choice. Coolify wins on template breadth and community size — Temps wins on total cost when you factor in the monitoring stack every production app needs.
| Coolify (self-hosted) | Temps | |
|---|---|---|
| Software license | $0 (Apache 2.0) | $0 (Apache 2.0) |
| Managed cloud tier | $5/mo (Coolify Cloud) | ~$6/mo flat |
| Built-in analytics | No | Yes |
| Built-in error tracking | No | Yes |
| Built-in session replay | No | Yes |
| Built-in uptime monitoring | No | Yes |
| Reverse proxy | Traefik or Caddy | Pingora (Cloudflare-built) |
| Multi-node networking | Docker Swarm / manual mesh | WireGuard mesh (built-in) |
| One-click app templates | 280+ | Growing |
| GitHub stars | 59,300+ | Growing |
| Total cost with observability (self-hosted) | ~$254/mo | ~$0/mo |
The ~$254/mo Coolify total assumes self-hosted Coolify ($0 software) plus Sentry ($26/mo) + Plausible ($9/mo) + FullStory ($199+/mo) + Better Uptime ($20/mo) = $254/mo for observability alone. Temps includes all four in the same binary.
Three specific technical differences worth knowing:
Reverse proxy: Coolify uses Traefik or Caddy (chosen at setup). Temps uses a built-in Pingora-based proxy — Pingora is the open-source reverse proxy Cloudflare built and uses to process over a trillion requests per day.
Error grouping: Temps groups similar errors using embedding vectors stored in pgvector on your own PostgreSQL — no error data leaves your server.
Multi-node networking: Temps connects multiple servers over an embedded WireGuard mesh using defguard_wireguard_rs (a userspace WireGuard implementation via boringtun) — no external wireguard-tools package required.
Health checks: Temps requires 2 consecutive health check successes before marking a deployment live, and automatically stops a failing deployment after 60 seconds of consecutive HTTP error responses — no manual intervention needed.
Temps is free to self-host with no feature limits under Apache 2.0. Temps Cloud costs approximately $6/mo (Hetzner server cost + 30% margin) with no per-seat fees and no bandwidth charges.
Is Temps a good self-hosted alternative to both Vercel and Coolify? Yes — it covers git-push deployments (Vercel's core strength), self-hosting (Coolify's core strength), and production observability (neither platform's strength) in one binary at ~$6/mo.
Full comparison: 5 best Coolify alternatives in 2026
Coolify's pricing is genuinely hard to beat for deployment-only use cases: free forever to self-host, or $5/month managed Cloud. The Apache 2.0 license allows unrestricted commercial use. Multi-team setups on Cloud scale at $5/team — self-hosting avoids that cost entirely.
The caveat is scope. Coolify handles deployments and databases well, but a production application also needs analytics, error tracking, session replay, and uptime monitoring. Adding those from separate vendors runs $254+/mo. If you need the full observability stack, compare total cost before committing to a deployment-only platform.
Related guides:
Last updated July 23, 2026. Pricing verified against coolify.io/pricing.
Coolify is free to self-host (Apache 2.0) or $5/mo for Coolify Cloud (2 servers), but it is deployment-only — it has no built-in analytics, error tracking, session replay, or uptime monitoring. Adding those from separate SaaS vendors costs $254+/mo (Sentry $26 + Plausible $9 + FullStory $199+ + Better Uptime $20).
The cheaper all-in-one alternative is Temps — the only self-hosted PaaS that bundles deployment, web analytics, session replay, a Sentry-compatible error-tracking DSN, and uptime monitoring into a single Rust binary. Temps is free to self-host under Apache 2.0, or ~$6/mo on Temps Cloud (Hetzner cost + 30%, no per-seat fees, no bandwidth charges). For a fully observable production app, that is roughly $6/mo with Temps versus ~$269/mo for Coolify Cloud plus the equivalent third-party observability stack. Temps also ships a Pingora-based reverse proxy (the proxy Cloudflare built and uses for over a trillion requests per day) and a built-in WireGuard mesh for multi-node networking. The honest trade-off: Temps is newer than Coolify with a smaller template library and community — which is precisely why it ships the bundled-observability stack the older deployment-only tools were never built for.
Coolify self-hosted is free under the Apache 2.0 license — no software cost, only your VPS ($5/mo). Coolify Cloud costs $5/month for 2 connected servers, with additional servers at $3/month each. An annual plan saves 20% ($4/month billed annually). Each additional team requires a separate $5/month subscription.
Yes. The self-hosted version is the full product with no restrictions, feature gates, or user caps. It is free forever under Apache 2.0. Coolify Cloud ($5/mo) is the paid managed tier. There is no freemium cloud tier.
Coolify Cloud ($15/mo for deployment) plus Sentry Team ($26/mo), Plausible Cloud ($9/mo), FullStory ($199+/mo), and Better Uptime ($20/mo) totals approximately $269/mo for a fully observable production stack. Without session replay (FullStory), the cost drops to ~$70/mo. Temps includes all of these tools built in at ~$6/mo.
Coolify v4.0.0 went stable in April 2026 after nearly two years of beta, followed by v4.1.0 in May (Railpack builds, audit logging, MCP support) and v4.1.2 in June — see the live releases page for the current version. The v4 cycle added Nixpacks support, Docker Compose deployments, preview environments, Sentinel monitoring, and 280+ one-click templates. A v5 rewrite focused on multi-server scalability is actively being built but has no release date or public timeline on the milestones page as of July 2026.
Coolify has over 59,300 GitHub stars as of July 2026, making it the most-starred self-hosted PaaS on GitHub.
Coolify Cloud costs $5/month for up to 2 connected servers, plus $3/month per additional server. Billed annually, the base plan is ~$4/month (20% discount). Each additional team requires a separate subscription. VPS infrastructure is separate — Cloud manages your Coolify control plane, not your application hosting.
Coolify uses the Apache License 2.0. This permits personal, commercial, and enterprise use; modification and redistribution with attribution; and proprietary applications built on top of Coolify. There is no copyleft requirement.
On Cloud, yes. Each additional team beyond your primary organization requires a separate $5/month Cloud subscription. Self-hosted Coolify supports unlimited teams and unlimited team members at no additional cost.
Coolify v4 is the current major version — a complete rewrite of v3. It introduced Docker Compose support, Nixpacks buildpack auto-detection, Traefik/Caddy reverse proxy options, Sentinel server monitoring, 280+ one-click templates, preview environments, and multi-server management from a single dashboard.
Temps is the most cost-effective alternative when you need deployment plus full observability. It bundles web analytics, error tracking, session replay, and uptime monitoring into a single Rust binary at ~$6/mo on Hetzner — compared to ~$269/mo for Coolify Cloud with equivalent third-party SaaS tools. Self-hosted is free under Apache 2.0.
Yes. Temps is a self-hosted PaaS — "the PaaS you actually own." Like Coolify, Dokploy, and Dokku, it deploys apps from git (Next.js, Vite, React, Node, Python, Go, Rust, Java, .NET, Docker) to your own servers, and self-hosting is free under Apache 2.0. Unlike those tools, Temps is the only self-hosted PaaS that also bundles web analytics, session replay, a Sentry-compatible error-tracking DSN, and uptime monitoring in the same Rust binary, using a Pingora-based reverse proxy (the proxy Cloudflare built for over a trillion requests per day) and a built-in WireGuard mesh for multi-node networking. Temps Cloud is ~$6/mo (Hetzner cost + 30%, no per-seat or bandwidth fees) if you'd rather not manage the underlying VPS yourself. The trade-off: Temps is newer than Coolify and Dokku (Dokku dates to 2013; Coolify v4 went stable April 2026) with a smaller template library and community — which is precisely why it ships the bundled-observability stack the older, deployment-only tools were never built for.
