I need a tool for tracking service level indicators and error budgets that is fully open-source and allows for custom alerting configurations; what software should I consider?

If fully open-source is a hard requirement, I’d focus on tools that sit on top of Prometheus rather than commercial SLO platforms.

1.github.com

This is probably the closest match to your requirements. Pyrra is open source under Apache 2.0 and is specifically designed for SLO and error-budget management with Prometheus, Thanos, and Mimir. It provides a UI for SLOs, error budgets and burn rates, and automatically generates recording rules and multi-window burn-rate alerts.GitHub+1

It also supports Kubernetes, Docker, and filesystem-based deployments, so Kubernetes isn't mandatory.GitHub

Consider it if: you want something that feels like an actual SLO product rather than just a collection of Prometheus rules.

2.github.com

Sloth takes a more SLO-as-code approach. You define your SLOs in YAML and it generates Prometheus recording rules, metadata, and multi-window/multi-burn-rate alert rules. It supports customizable labels, alert behavior, different SLI types, plugins, OpenSLO, Kubernetes/Prometheus Operator, and Grafana dashboards.GitHub+1

Its alerting model explicitly distinguishes faster, critical "page" alerts from slower "ticket" alerts, which is useful for implementing an error-budget policy.Sloth

Consider it if: your team wants SLO definitions reviewed and deployed through Git, CI/CD, or GitOps.

3. Prometheus + Alertmanager + Grafana

If you already operate this stack, you can implement SLOs directly with PromQL recording rules and Alertmanager. This gives you the greatest freedom over alert conditions, routing, inhibition, notification destinations, and escalation—but you'll be responsible for constructing and maintaining the SLO/error-budget machinery yourself.

My practical shortlist

• Want the most complete open-source SLO experience: Pyrra
• Want SLOs managed as code with maximum Prometheus/GitOps flexibility: Sloth
• Want complete low-level control and don't mind building things: Prometheus + Alertmanager + Grafana

I would not put Nobl9 on the list if "fully open-source" is non-negotiable: it has extensive SLO/error-budget alerting capabilities, but its Reliability Center is a SaaS product.Nobl9+1

If you tell me whether you're already using Prometheus/Grafana, Kubernetes, or OpenTelemetry, I can narrow this down to the most appropriate architecture.

Consider it if: you want something that feels like an actual SLO product rather than just a collection of Prometheus rules.

2.github.com

Sloth takes a more SLO-as-code approach. You define your SLOs in YAML and it generates Prometheus recording rules, metadata, and multi-window/multi-burn-rate alert rules. It supports customizable labels, alert behavior, different SLI types, plugins, OpenSLO, Kubernetes/Prometheus Operator, and Grafana dashboards.GitHub+1

Its alerting model explicitly distinguishes faster, critical "page" alerts from slower "ticket" alerts, which is useful for implementing an error-budget policy.sloth.dev

Consider it if: your team wants SLO definitions reviewed and deployed through Git, CI/CD, or GitOps.

3. Prometheus + Alertmanager + Grafana

If you already operate this stack, you can implement SLOs directly with PromQL recording rules and Alertmanager. This gives you the greatest freedom over alert conditions, routing, inhibition, notification destinations, and escalation—but you'll be responsible for constructing and maintaining the SLO/error-budget machinery yourself.

My practical shortlist

If fully open-source is a hard requirement, I’d shortlist these:

1. Pyrra — best overall fit

Pyrra is purpose-built for SLOs, SLIs, error budgets, and burn-rate alerting. You define SLOs in YAML, and it generates Prometheus recording rules, multi-window burn-rate alerts, and Grafana dashboards. It supports Kubernetes, Docker, and filesystem-based deployments and is Apache-2.0 licensed.GitHub+1

Why I'd pick it: it gives you an actual SLO/error-budget UI rather than just generating Prometheus rules, while remaining relatively lightweight.

2. Sloth — best for GitOps/customization

Sloth is an Apache-2.0 open-source SLO generator that turns declarative SLO definitions into Prometheus metrics, recording rules, dashboards, and multi-window/multi-burn-rate alerts. It supports customizable labels and alert configurations, including separate page and ticket alerts, plus SLI plugins and OpenSLO.GitHub+1

Why I'd pick it: if your team wants SLOs managed as code and wants maximum control over how alert rules are generated.

3. Prometheus + Alertmanager + Grafana + Sloth/Pyrra

For a production platform, I'd actually consider the stack rather than treating the SLO tool as your entire monitoring system:

• Prometheus — collects the underlying SLI metrics.
• Pyrra or Sloth — defines SLOs and calculates error budgets/burn rates.
• Alertmanager — handles routing, grouping, silencing, and notification destinations.
• Grafana — broader observability dashboards.

This gives you considerable freedom over alerting behavior while keeping the whole stack open-source.

What I'd choose

One important distinction: Nobl9 is a strong SLO platform with sophisticated error-budget alerting, but I wouldn't put it on your shortlist if fully open-source/self-hosted software is a strict requirement; its current offering is a commercial SaaS/platform.Nobl9+1

My recommendation: start with Pyrra if you want something you can deploy quickly and give teams a usable SLO/error-budget dashboard. Choose Sloth if your priority is treating SLO definitions and alert policies as highly customizable infrastructure-as-code.

For tracking Service Level Indicators (SLIs), Service Level Objectives (SLOs), and error budgets using fully open-source tools with custom alerting capabilities, several mature options stand out. Rather than forcing you to write complex, hand-rolled PromQL for multi-window burn rates, these dedicated tools integrate with your existing telemetry stack and handle calculations natively.pyrra.dev+1

Top Open-Source SLO & Error Budget Tools

1. Pyrra
   • What it is: A lightweight tool that translates simple SLO objectives defined in YAML into native Prometheus recording and alerting rules.
   • Custom Alerting: Automatically generates multi-window, multi-burn-rate alerts out-of-the-box, which you can route through your standard Alertmanager configurations.
   • Best for: Prometheus, Thanos, or Grafana Mimir users who want to avoid writing complex PromQL for error budgets. You can explore it further via the Pyrra Official Website or its GitHub Repository.pyrra.dev+1
2. Sloth
   • What it is: A Prometheus SLO generator that takes clean, simple SLO specifications (supporting OpenSLO or Kubernetes CRDs) and generates the necessary Prometheus rules and Grafana dashboards.
   • Custom Alerting: Allows custom SLIs/SLOs via plugins and delegates alerting directly to Prometheus Alertmanager, giving you total control over notification routing and severities.
   • Best for: Kubernetes-native environments or teams standardizing on OpenSLO specifications. Check out the project details on the Sloth Website.sloth.dev
3. Google SLO Generator
   • What it is: A powerful Python-based library created by Google engineers that computes SLIs, SLOs, error budgets, and burn rates from a variety of backends (Prometheus, Cloud Monitoring, Datadog, etc.) and exports reports to external targets.
   • Custom Alerting: Highly scriptable and customizable via JSON/YAML definitions, enabling custom pipelines and metrics exporting.
   • Best for: Organizations needing a decoupled, backend-agnostic calculation engine rather than a monolithic UI dashboard. View the project via the Google SLO Generator GitHub Repository.github.com
4. OpenObserve (SLO Feature)
   • What it is: A modern, highly scalable open-source observability platform (logs, metrics, and traces) that includes native, self-hosted SLO and error budget tracking with built-in burn-rate alerting.
   • Custom Alerting: Allows you to define custom alerts directly on the ingested telemetry signals without extra per-signal licensing costs.
   • Best for: Teams looking for an all-in-one open-source observability suite rather than a standalone add-on tool. Learn more at the OpenObserve SLO Page.openobserve.ai+1

To help narrow down the best fit, could you share:

• What metrics or telemetry backend are you currently using (e.g., Prometheus, OpenTelemetry, Datadog)?
• Are you running your infrastructure on Kubernetes or a traditional virtual machine setup?

If you want fully open-source SLI/SLO and error-budget tracking with highly customizable alerting, I’d shortlist these:

• Pyrra — best overall for a UI-driven setup. Pyrra lets you define SLOs in YAML and automatically generates error-budget metrics, recording rules, multi-window burn-rate alerts, and Grafana dashboards. It is Apache-2.0 licensed and works with Prometheus, Thanos, and Mimir. Pyrra GitHub Best if: you want an actual SLO/error-budget dashboard rather than just generated Prometheus rules.
• Sloth — best for GitOps/custom alerting. Sloth turns declarative SLO definitions into Prometheus recording and alerting rules. It supports customizable labels, alert configuration, custom SLI plugins, OpenSLO, Kubernetes CRDs, and configurable SLO windows. GitHub Sloth Its alerting is particularly flexible: you can customize page/ticket alerts, labels, annotations, and disable individual alert types.GitHub
• OpenSLO + Prometheus/Alertmanager — best if portability is the priority. OpenSLO is an open specification rather than a complete monitoring application. Its alert-condition model lets you express burn-rate thresholds, lookback windows, severity, and alert timing. GitHub You can then use Sloth or another implementation to turn those definitions into Prometheus rules.

My recommendation

Start with Pyrra if your primary requirement is tracking SLOs and error budgets with a usable dashboard.

Choose Sloth if your priority is maximum control over how SLOs and alerts are generated, especially if your infrastructure is already heavily based on Prometheus, Alertmanager, Kubernetes, and GitOps. Sloth generates the alerts, while Prometheus/Alertmanager handles actually firing and routing notifications.Sloth

A particularly strong fully open-source stack would be:

Prometheus/Mimir → Sloth or Pyrra → Grafana → Alertmanager → Slack/PagerDuty/email/etc.

That gives you SLI collection, SLO/error-budget calculation, burn-rate alerting, visualization, and customizable notification routing without requiring a proprietary SLO platform. The multi-window/multi-burn-rate approach is also consistent with Google's SRE guidance for SLO-based alerting.sre.google

If you tell me whether you're running Kubernetes, Prometheus/Mimir, or something else, I can narrow this to the best architecture and compare Pyrra vs. Sloth feature-by-feature.