OneUptime

Open-source monitoring, incident management, and APM — honestly reviewed. No marketing fluff, just what you get when you self-host it.

TL;DR

• What it is: Open-source (Apache-2.0) observability platform that combines uptime monitoring, status pages, on-call scheduling, incident management, logs, metrics, distributed tracing, and error tracking into one self-hostable stack [merged profile].
• Who it’s for: Engineering teams and technical founders paying for 2–4 separate SaaS tools (Datadog, PagerDuty, StatusPage.io, Sentry) who want to consolidate onto a single self-hosted platform. Less suitable for non-technical teams expecting a five-minute setup [1][2].
• Cost savings: Replacing Datadog + PagerDuty + StatusPage.io separately can easily run $300–$1,000+/month for a small team. OneUptime self-hosted runs on a VPS with no per-host, per-seat, or per-GB pricing [2][merged profile].
• Key strength: Genuinely replaces multiple paid tools, not just one. The Apache-2.0 license is real — no “Fair-code” gotchas, no commercial redistribution restrictions [merged profile][2].
• Key weakness: The project has publicly criticized SSO paywalls while simultaneously gating SSO behind paid plans on its own cloud offering — a credibility gap worth knowing about before you commit [4]. Installation requires real infrastructure knowledge.

---

What is OneUptime

OneUptime is an observability platform that tries to do something genuinely ambitious: replace the entire monitoring and incident-response toolchain with one self-hostable application. The README lays it out as a comparison table — replace Pingdom with uptime monitoring, replace StatusPage.io with status pages, replace PagerDuty with on-call alerts, replace Incident.io with incident management, replace Loggly with log management, replace New Relic/Datadog with APM, replace Sentry with error tracking [merged profile].

That’s seven distinct SaaS products. The pitch is not “we’re better than each one.” The pitch is that running all of them through a single data model — where a monitor failure automatically updates a status page, triggers an on-call alert, opens an incident, and starts collecting correlated logs and traces — is worth the trade-off of running your own infrastructure.

The project is Apache-2.0 licensed, which is the important part. Not MIT (which would also work), not “Fair-code” (which has commercial redistribution restrictions, as n8n uses), not BSL (which restricts production use). Apache-2.0 means you can deploy it internally, embed it in a product you sell, or host it for clients without a legal conversation [merged profile][2]. As of this review, the GitHub repository has 6,668 stars [merged profile].

The company also runs a managed cloud version with a free tier, and there are third-party managed hosting providers like Stellar Hosted starting at €49/month [3]. Self-hosting is Docker Compose or Helm on Kubernetes [merged profile].

---

Why people choose it

The r/devops thread [1] where the OneUptime team asked for feedback is worth reading for signals — not for what the developer said, but for what the community didn’t push back on. The thread was archived without a flood of complaints, which in the devops subreddit is roughly equivalent to a passing grade. The comparison that keeps appearing is not “is it better than Datadog” but “can I stop paying for four separate tools.”

The consolidation argument. The PagerDuty comparison page [2] makes the case clearly: PagerDuty requires integrating external monitoring and separate status page tools. OneUptime has all of it in one data model. When an alert fires, it doesn’t need a webhook chain to update the status page — the monitor, the incident, and the status page are the same object in the same database. For small teams that have been duct-taping five tools together with API calls, this is genuinely appealing.

The license argument. Apache-2.0 is a hard differentiator in this category. Datadog, New Relic, and PagerDuty are fully closed SaaS. Grafana uses AGPL for some components and charges for enterprise features. OpenTelemetry is Apache-2.0 but is a protocol, not a platform. OneUptime being Apache-2.0 means the vendor cannot change the terms, cannot raise prices on your self-hosted instance, and cannot restrict how you use it commercially [2][merged profile].

The pricing model. The website explicitly claims “10x cheaper than Splunk. No per-GB pricing surprises” for log management, and “Keep 13 months of history. No data retention limits” for metrics [website scrape]. These aren’t features — they’re jabs at the pricing models of commercial alternatives where bills grow with data volume.

The SSO controversy. Here is where honesty requires a harder look. In August 2025, the Self-Host Weekly newsletter [4] noted that “OneUptime published an article preaching against SSO paywalls despite actively implementing one themselves.” The PagerDuty comparison page [2] shows OneUptime offering SSO on its cloud plans, but SSO paywalling is exactly the practice the self-hosted community has been vocal about opposing. This isn’t a deal-breaker for self-hosted deployments (you control your own auth stack), but it signals that the company’s public positioning sometimes diverges from its commercial decisions — worth factoring into how much you trust future pricing moves.

---

Features

Uptime monitoring:

• HTTP/HTTPS, TCP, UDP, DNS monitoring from 100+ global probe locations [website scrape]
• Check intervals as fast as every 10 seconds [website scrape]
• SSL certificate expiration alerts [website scrape]
• Synthetic monitoring — multi-step transaction tests that simulate real user flows [website scrape]
• Smart alert deduplication to reduce noise [2]

Status pages:

• Public and private status pages with custom domains and branding [website scrape][2]
• Automatic or manual updates from monitors [website scrape]
• 90-day uptime history visible to subscribers [website scrape]
• Subscriber notifications via email, SMS, RSS [website scrape]
• Unlimited subscribers on self-hosted [2]

Incident management:

• Declare incidents directly from Slack or Teams [website scrape]
• Automatic timeline capturing every action [website scrape]
• One-click status page updates from an active incident [website scrape]
• Built-in postmortem templates [website scrape]

On-call and alerting:

• Phone calls, SMS, Slack, Teams, email alert channels [2][website scrape]
• Daily, weekly, monthly, or custom rotation schedules [2]
• Multi-level escalation with configurable timeouts [2]
• Vacation and override schedules [2]
• Follow-the-sun scheduling for global teams [2]

Logs, metrics, traces:

• Real-time log tail and terabyte-scale search [website scrape]
• Prometheus, StatsD, and OpenTelemetry compatible metrics [website scrape]
• 13-month metric retention with no data limits claimed [website scrape]
• Distributed tracing with auto-discovery of service dependencies [website scrape]
• Trace-to-log linking for cross-signal debugging [website scrape]

Error tracking:

• Stack traces with source maps and context [website scrape]
• Error grouping to eliminate duplicate noise [website scrape]
• Deploy-attribution (“which deploy introduced this bug”) [website scrape]

AI Copilot:

• Anomaly detection across logs, traces, and metrics [merged profile]
• Automated root cause analysis [merged profile]
• AI-generated code fix suggestions submitted as pull requests [merged profile]
• One-click auto-instrumentation for tracing and metrics [merged profile]

Workflows:

• Drag-and-drop workflow builder [website scrape]
• Trigger on alerts, schedules, or webhooks [website scrape]
• Connects to Slack, Jira, GitHub, and custom scripts [website scrape]

---

Pricing: SaaS vs self-hosted math

Specific cloud pricing tiers for OneUptime are not fully detailed in the available sources — the website offers a free tier and a “Request a demo” path for enterprise, but the intermediate pricing structure was not available for this review. What is visible: the free cloud tier exists, and the self-hosted path is $0 for the software [website scrape][merged profile].

For context on what you’re replacing:

Datadog infrastructure monitoring: starts around $15/host/month. A 10-host setup costs $150/month, and that’s before APM, logs, or custom metrics, which each add their own per-unit costs. Realistic small-team bills run $300–$800/month.

PagerDuty: Business plan starts around $21/user/month. A 5-person on-call rotation is $105/month. Enterprise tiers run significantly higher. Alert deduplication via AIOps is an add-on at $699/month [2].

StatusPage.io (Atlassian): $79–$399/month depending on subscriber count.

Add Sentry ($26+/month) and Loggly or similar ($49+/month) and a typical small engineering team is spending $500–$1,200/month on tools that OneUptime consolidates.

Self-hosted OneUptime:

• Software: $0 (Apache-2.0)
• Infrastructure: a Kubernetes cluster or Docker Compose on a VPS. The Helm chart suggests this is not a single-container application — expect 4–8GB RAM minimum for a functional setup
• Managed hosting via Stellar Hosted: from €49/month (coming soon at time of writing) [3]

The savings math is compelling if you’re already running 3+ monitoring tools. If you’re only using one light-weight tool today, the operational overhead of self-hosting a full observability stack may not be worth the savings.

---

Deployment reality check

OneUptime is not a simple self-hosted app. The feature list — metrics, traces, logs, on-call routing, status pages, synthetic monitoring — maps to significant architectural complexity underneath. The deployment path is Docker Compose or Helm on Kubernetes [merged profile].

What you actually need:

• Docker Compose deployment: a VPS with at least 4GB RAM, likely 8GB for production workloads handling real metrics/log volumes
• Kubernetes deployment (Helm): an existing cluster or a managed Kubernetes service (EKS, GKE, DigitalOcean Kubernetes)
• A domain name with HTTPS via a reverse proxy
• SMTP for alert notifications
• Persistent storage for PostgreSQL, Redis, and the log/metrics backends

What can go sideways:

• The platform bundles many microservices. The Helm chart isn’t a “one-line install” — it requires understanding what you’re deploying.
• Log and metrics ingest at scale requires sizing storage properly upfront. “13 months of retention” is free in the software sense, but it’s not free in the storage sense.
• The SSO situation for cloud users (gated, as noted in [4]) doesn’t affect self-hosted deployments directly, but if you’re relying on SAML/SSO for your self-hosted instance, confirm it’s available in the open-source version before committing.
• Stellar Hosted’s managed offering was listed as “coming soon” at time of writing [3], so third-party managed hosting options for those who want a turnkey deployment are still thin.

Realistic time estimate for a DevOps-experienced user: 2–4 hours for a Docker Compose setup on a fresh server. For Kubernetes production deployment with proper persistence and alerting: a full day including configuration and testing. Not a weekend project for someone new to containers.

---

Pros and Cons

Pros

• Apache-2.0 license. No commercial use restrictions, no vendor lock-in via licensing, no “fair-code” gotchas. You own your deployment [merged profile][2].
• Genuine consolidation. Replaces 7 distinct SaaS products in a single data model. Monitors, incidents, status pages, on-call, logs, traces, and errors share context automatically [merged profile][website scrape].
• No per-unit pricing on self-hosted. No per-host, per-GB log ingestion, per-seat, or per-alert charges on the self-hosted version. Scale your monitoring without watching a billing meter [website scrape].
• OpenTelemetry compatible. Works with the OTEL standard for metrics, logs, and traces — meaning you’re not locked into OneUptime’s instrumentation SDK [website scrape].
• Global probe network. 100+ monitoring locations without needing to manage your own probe infrastructure [website scrape].
• SOC 2 Type II compliance on the managed cloud for teams that need it [merged profile].
• Active development. Featured in Self-Host Weekly in August 2025 [4], indicating ongoing activity.

Cons

• SSO paywall hypocrisy. OneUptime has publicly criticized SSO paywalls while gating SSO on their own cloud offering [4]. This isn’t a technical limitation, but it’s a trust signal worth noting.
• Complex self-hosting. This is not a single-service Docker container. Running logs, metrics, traces, and all monitoring at production scale requires real infrastructure and ops attention.
• Limited third-party reviews. The community feedback available [1] is minimal. There are no in-depth third-party comparisons from dedicated monitoring practitioners the way Activepieces or n8n have. The confidence level in this review’s assessment of reliability and edge-case behavior is correspondingly lower.
• Managed hosting thin. Stellar Hosted’s managed tier was “coming soon” at the time of the available data [3]. Teams that want someone else to handle ops have limited options.
• Small GitHub star count relative to category. 6,668 stars [merged profile] is healthy for a younger project but modest compared to Grafana (60k+), Prometheus (55k+), or even Uptime Kuma (60k+ for a much simpler tool). Smaller community = fewer battle-tested deployments to learn from.
• Feature breadth vs. depth trade-off. Covering 7 product categories in one codebase means each individual feature may be less mature than a dedicated tool. Sentry’s error tracking is deeper than OneUptime’s. Datadog’s APM has more AI-driven insights. This is a consolidation play, not a “best in class at everything” play.

---

Who should use this / who shouldn’t

Use OneUptime if:

• You’re a small engineering team running Datadog + PagerDuty + StatusPage.io and the combined bill is $300+/month — the consolidation math works.
• You have a DevOps engineer or a technically capable founder comfortable with Kubernetes or Docker Compose administration.
• You need Apache-2.0 licensing for compliance, resale, or open-source policy reasons.
• You want a unified timeline across monitors → incidents → status page without stitching webhooks across tools.
• You’re building a product that needs white-labeled status pages and monitoring at scale without per-subscriber SaaS costs.

Skip it (use Uptime Kuma) if:

• You only need basic uptime monitoring and a status page with minimal operational overhead. Uptime Kuma is a single-container tool with 60k+ stars and is far simpler to run.

Skip it (use Grafana + Prometheus) if:

• You’re an experienced SRE team that already runs an observability stack and wants maximum flexibility, community, and integration depth. Grafana’s ecosystem is vastly larger.

Skip it (use Datadog/New Relic) if:

• Your team lacks the ops capacity to maintain self-hosted infrastructure. An unmaintained observability platform is worse than a paid one — you won’t know when your monitoring is broken.

Skip it (stay on PagerDuty) if:

• You have complex on-call requirements with large global teams and need a mature, battle-tested platform with a vendor SLA backing it.

---

Alternatives worth considering

• Uptime Kuma — single-container uptime monitor and status page. 60k+ stars, trivially simple to deploy, no APM or on-call. Right for teams that only need the monitoring + status page slice.
• Grafana + Prometheus + Alertmanager — the industry standard observability stack. Vastly more community resources, integrations, and documentation. Higher ops complexity but more mature than OneUptime for every individual component.
• Datadog — the incumbent. Best-in-class APM and ML-driven anomaly detection. Expensive at scale, fully closed source, no self-host option.
• New Relic — similar position to Datadog. Free tier up to 100GB/month, usage-based pricing after.
• PagerDuty — the on-call and incident management incumbent. Integrates with every monitoring tool but is expensive ($21+/user/month) and requires external monitoring [2].
• Better Uptime / HetrixTools — simpler SaaS uptime monitors with status pages. Good if you don’t need APM or full incident management.
• Checkmk / Zabbix — traditional open-source infrastructure monitoring with long track records. Less modern UX, more mature for enterprise on-premise deployments.

---

Bottom line

OneUptime’s core proposition is legitimate: if you’re paying for three or four separate monitoring and incident tools, consolidating onto a single Apache-2.0 platform running on your own infrastructure can cut your bill dramatically. The feature list is genuinely broad — this isn’t uptime monitoring with a status page bolted on, it’s a real attempt at a unified observability stack.

The honest caveats are two: it requires real operational competence to deploy and maintain, and the project’s credibility took a visible hit in 2025 when it publicly criticized SSO paywalls while implementing one [4]. For self-hosted users the SSO policy on the cloud tier is irrelevant, but the gap between public positioning and commercial decisions is worth noting when you’re betting your team’s alerting stack on a vendor’s roadmap integrity.

For a technically capable team spending $400+/month across monitoring tools and willing to own the infrastructure, OneUptime is worth serious evaluation. For everyone else, start with Uptime Kuma for the basics and add Grafana when you grow into it.

If the deployment complexity is the blocker, upready.dev deploys and maintains self-hosted infrastructure like this for clients — one-time setup, you own it.

---

Sources

1. r/devops — “Feedback for OneUptime: Open Source Monitoring and Observability Platform” (archived thread). https://www.reddit.com/r/devops/comments/1i1xa5y/feedback_for_oneuptime_open_source_monitoring_and/
2. OneUptime — “PagerDuty Alternative” comparison page. https://oneuptime.com/compare/pagerduty
3. Stellar Hosted — “OneUptime hosting: Managed, fast and secure”. https://www.stellarhosted.com/oneuptime/
4. Ethan Sholly, selfh.st — “Self-Host Weekly (22 August 2025)”. https://selfh.st/weekly/2025-08-22/
5. OneUptime — “Our Open Source Friends” (OSS Friends page). https://oneuptime.com/oss-friends

Primary sources:

• GitHub repository: https://github.com/oneuptime/oneuptime (6,668 stars, Apache-2.0 license)
• Official website: https://oneuptime.com
• Documentation: https://oneuptime.com/docs
• Pricing page: https://oneuptime.com/pricing