RousselTMLEARNING

Observability

Time-based vs event-based SLO: understanding, computing and choosing (with the Qonto example)

Differences between time-based SLOs (time slices, uptime) and event-based SLOs (good events over total): definitions, calculations, error budget, a worked incident, implementation with Prometheus and OpenSLO, pitfalls, and the example of Qonto's status page.

1. Recap: SLI, SLO and error budget #

The vocabulary shared by both methods.

The concepts #

TermDefinitionExample
SLImeasured indicator of service qualityshare of payments accepted in under 2 s
SLOtarget set on that SLI, over a window99.9% over a rolling 30 days
SLAcontractual commitment, with penalties99.5% per month, otherwise credit
Error budgetwhat you allow yourself to miss: 100% − SLO0.1% of minutes or requests
Burn ratespeed of budget consumption (1 = the budget lasts exactly the window)14.4: 30-day budget exhausted in 2 days

Everything rests on one simple question: what do we count? Either time slices (“how many minutes was the service good?”) or events (“how many requests were served well?”). That is the whole difference between the two SLO families.

Good to know : For the basics, see SLI, SLO and SLA explained simply and The error budget.

2. The time-based SLO #

Time slices, or the uptime logic.

Principle #

Time-based SLO

The window is cut into slices (often one minute). For each slice, an SLI is computed (error rate, p95 latency, probe response) and the slice is declared good or bad against a threshold. The SLO is about the share of good slices. It is the historical “uptime” logic and that of most contractual SLAs.

SLI = good minutes / minutes in the window
good minute  ⇔  minute error rate < 5%  AND  minute p95 < 500 ms

30 days = 43,200 minutes; 99.9% SLO  ⇒  budget = 43.2 bad minutes

The “nines” table #

SLOBudget over 30 daysBudget over 90 daysBudget over 1 year
99%7 h 12 min21 h 36 min3 d 15 h 36 min
99.5%3 h 36 min10 h 48 min1 d 19 h 48 min
99.9%43 min 12 s2 h 9 min 36 s8 h 45 min 36 s
99.95%21 min 36 s1 h 4 min 48 s4 h 22 min 48 s
99.99%4 min 19 s12 min 58 s52 min 34 s

Strengths and weaknesses #

StrengthsWeaknesses
intuitive: “the service was down for 12 minutes”arbitrary binary threshold: 4.9% errors = perfect minute, 5.1% = lost minute
works with little or no traffic (synthetic probes)ignores partial degradations below the threshold, even long ones
aligned with contractual SLAs expressed in minutesa night minute weighs as much as a peak minute
robust against one client's traffic spikessensitive to slice size and probe frequency

3. The event-based SLO #

Request-based, or the user experience logic.

Principle #

Event-based SLO

You count events (HTTP requests, payments, logins, processed messages) and classify each as good or bad against a criterion: succeeded, and possibly fast enough. The SLI is the good / total ratio over the window. The error budget is expressed as a number of failed events.

SLI = good events / total events
good  ⇔  status ≠ 5xx  AND  duration < 300 ms

30 million requests per month; 99.9% SLO  ⇒  budget = 30,000 failed requests

Strengths and weaknesses #

StrengthsWeaknesses
proportional to users affected: a peak outage costs more than a night outagelow traffic = noise: 1 error in 20 requests drops the SLI to 95%
captures partial degradations: 2% errors for hours really consume budgetrequests that never arrived are not counted when measured server-side
no arbitrary per-slice thresholda night outage weighs little, even if it blocks critical customers
natural burn rate and precise multi-window alertssensitive to retries and to how an event is defined
Good to know : Google SRE recommends event-based SLIs (“proportion of good events”) by default for services with enough traffic, and keeps time slices for low or irregular traffic.

4. The same month, measured both ways #

Three incidents telling two stories.

Assumptions #

  • Payment API, about 30 million requests per month: 100 requests per minute at night, 1,000 during the day, 3,000 at peak.
  • 99.9% SLO over 30 days: budget of 43.2 minutes (time) or 30,000 requests (events).
  • Time side: a minute is bad if more than 5% of requests fail.

Results #

IncidentTime: minutes lostTime: budgetEvents: failed requestsEvents: budget
A. Full outage for 30 min at 3 a.m.3069%3,00010%
B. 4% errors for 10 h during the day00%24,00080%
C. Full outage for 20 min at peak hour2046%60,000200%
Error budget consumed per incident

What it shows #

  • Incident A: the time SLO raises the alarm (69% of budget) for an outage that hit very few customers; the event SLO puts it in perspective (10%).
  • Incident B: invisible to the time SLO (always below the 5% threshold), while 24,000 payments failed. The event SLO makes it the major incident of the month.
  • Incident C: the time SLO rates it less serious than A; the event SLO shows it alone exhausted the budget twice.
Best practice : Neither measure is “wrong”: they answer different questions. Time answers “how long was the service usable?”, events answer “what share of users were served well?”.

5. Implementing #

Prometheus, OpenSLO, SQL and market tools.

With Prometheus #

# Events: SLI = good requests / total requests (recording rules)
groups:
  - name: slo-payment
    rules:
      - record: sli:payment:ratio_rate5m
        expr: |
          sum(rate(http_requests_total{service="payment", code!~"5.."}[5m]))
          /
          sum(rate(http_requests_total{service="payment"}[5m]))
      # Burn rate over 1 h and 5 min: page if the 30-day budget burns 14.4 times too fast
      - alert: PaymentBudgetBurn
        expr: |
          (1 - sli:payment:ratio_rate1h) > (14.4 * 0.001)
          and
          (1 - sli:payment:ratio_rate5m) > (14.4 * 0.001)
        labels: { severity: page }

# Time: share of “good” minutes over 30 days (subquery, 1 min resolution)
avg_over_time(
  (
    (sum(rate(http_requests_total{service="payment", code=~"5.."}[1m]))
      / sum(rate(http_requests_total{service="payment"}[1m]))) < bool 0.05
  )[30d:1m]
)

On the event side, two counters are enough. On the time side, the [30d:1m] subquery evaluates each minute then averages the verdicts (1 or 0): expensive over 30 days, it is better computed with a per-minute recording rule.

To generate rules and alerts automatically, see Sloth and Pyrra.

With OpenSLO #

# OpenSLO v1: same target, two budgeting methods
apiVersion: openslo/v1
kind: SLO
metadata: { name: payment-evenements }
spec:
  service: payment
  budgetingMethod: Occurrences          # event-based
  objectives:
    - target: 0.999
  timeWindow: [{ duration: 30d, isRolling: true }]
  indicator:
    metadata: { name: payment-succes }
    spec:
      ratioMetric:
        good:  { metricSource: { type: Prometheus, spec: { query: 'sum(rate(http_requests_total{service="payment",code!~"5.."}[1m]))' } } }
        total: { metricSource: { type: Prometheus, spec: { query: 'sum(rate(http_requests_total{service="payment"}[1m]))' } } }
---
# Time variant: each minute is good if its ratio exceeds 95%
#   budgetingMethod: Timeslices
#   objectives: [{ target: 0.999, timeSliceTarget: 0.95, timeSliceWindow: 1m }]

The OpenSLO specification explicitly names both methods: Occurrences (events) and Timeslices (time), with a per-slice threshold (timeSliceTarget).

In SQL on traces #

-- Events from traces (ClickHouse, otel_traces table): SLI per day
SELECT toDate(Timestamp) AS day,
       countIf(StatusCode != 'Error' AND Duration < 300e6) / count() AS sli
FROM otel_traces
WHERE ServiceName = 'payment' AND SpanKind = 'Server' AND Timestamp > now() - INTERVAL 30 DAY
GROUP BY day ORDER BY day;

-- Time: share of minutes where the error rate stays below 5%
SELECT avg(rate < 0.05) AS sli_time FROM (
  SELECT toStartOfMinute(Timestamp) AS m, countIf(StatusCode = 'Error') / count() AS rate
  FROM otel_traces
  WHERE ServiceName = 'payment' AND SpanKind = 'Server' AND Timestamp > now() - INTERVAL 30 DAY
  GROUP BY m);

In tools #

ToolEventsTime
Grafana SLOratio of two queriesvia a slice query
Datadog“metric-based” SLO“monitor-based” and “time slice” SLOs
DynatraceSLO on metric or DQL ratioSLO on synthetic availability
Nobl9, Sloth, Pyrrayes (default method)Nobl9: yes; Sloth and Pyrra: event-oriented
Watch out : Labels and options change: check your tool's documentation, especially how it treats slices with no traffic (good, bad or ignored).

6. The Qonto example #

A status page expressed per customer journey.

What the status page shows #

The neobank Qonto moved to an event-based approach to express its reliability. Its public status page (status.qonto.com) shows availability per component, over a 90-day window, with four decimals. Components map to customer journeys rather than servers:

ComponentDisplayed availability (90 days, November 2026 reading)Event readingTime reading (equivalent)
Authentication99.9969%≈ 3 failures per 100,000 logins≈ 4 min over 90 days
Transactions99.9713%≈ 29 failures per 100,000 operations≈ 37 min over 90 days
Card payments99.9992%≈ 8 failures per million payments≈ 1 min over 90 days
Transfers99.9969%≈ 3 failures per 100,000 transfers≈ 4 min over 90 days

Figures are rolling and change daily; the “time reading” column only shows what the same percentage would mean if expressed in minutes.

Why this choice suits a bank #

  • Every event is a customer: a card payment wrongly declined is visible at the till, whatever the time. Counting failed payments directly reflects customer impact.
  • Partial degradations count: 1% of failed transfers during a morning is not an “outage” in uptime terms, but it is an incident for the customers involved (incident B in section 4).
  • Volume allows it: with millions of operations, the ratio is stable and precise, hence the value of four decimals.
  • Journeys rather than technical components: customers see “Card payments”, not “Kafka cluster”; each journey has its own SLO and budget.
  • A 90-day window smooths variations without hiding trends, and matches a quarterly steering horizon.

Takeaways for your own status page #

  1. Split by customer journey (sign in, pay, transfer), each with its event SLI.
  2. Measure as close to the user as possible (load balancer, gateway, client) to also count requests that never reach the service.
  3. Show a rolling window and a precision consistent with volume.
  4. Publicly explain the method (what a “good” event is): transparency builds trust.
  5. Keep UP, DEGRADED, DOWN and MAINTENANCE states for the present moment, and the percentage for history.
Good to know : Qonto does not publish the details of its calculation on this page (definition of a successful event, measurement point): the “≈ N failures” readings above are an arithmetic conversion of the displayed percentage, not figures communicated by Qonto.

7. Choosing, or combining #

Depending on traffic, contract and the question asked.

Decision grid #

SituationRecommended methodWhy
High-traffic API or journey (payments, search, login)eventsreflects the share of customers affected, captures partial degradations
Low-traffic service (back office, rarely called B2B API)time (with synthetic probes)avoids a single error crashing the SLI
Contractual SLA in minutestime for the SLA, events for internal steeringthe contract imposes the unit
Batch jobs, scheduled tasksevents (successful on-time runs)each run is an event
Very irregular traffic (seasonal peaks)events, complemented by probespeaks count more, troughs stay watched
Where to measure events

Combining both #

  • Events + probes: synthetic probes guarantee minimal traffic, so a full night-time outage still consumes budget.
  • Minimum traffic threshold: only count a window if it holds enough events, or aggregate over a longer window.
  • Multiple SLOs: an event SLO for perceived quality and a time SLO for contractual availability, shown side by side.

8. Common pitfalls #

What skews an SLO, whatever the method.

The pitfalls #

PitfallEffectFix
Measuring server-side onlya load balancer or DNS outage is not counted (zero events)measure at the load balancer or client, add probes
Counting retriesone user request becomes three eventscount the business operation, not the HTTP call
Counting 4xx as errorsclient errors consume your budgetexclude 4xx, except 429 and 408 if they are your limits
Poorly chosen slice thresholdinvisible degradations or excessive alertsbase the threshold on history, review it
Maintenance excluded without a ruleflattering SLO, loss of trustwritten, public exclusion rule
Single global SLOone large customer down disappears in the averageSLO per journey, even per customer segment
Best practice : Write the SLI definition like a contract: what an event is, what makes it good, where it is measured, what is excluded. That document, more than the tool, makes the SLO credible.

9. Key takeaways #

Summary, commands and sources.

Summary #

Time-based SLOEvent-based SLO
You countgood time slicesgood events
Budget expressed inminutesfailed events
Question askedhow long was the service usable?what share of users was served well?
Ideal forlow traffic, contractual SLAshigh traffic, customer experience, steering
Blind spotpartial degradations, traffic weightlow traffic, requests never received

Commands to know #

Commands to know
  • sum(rate(http_requests_total{code!~"5.."}[5m])) / sum(rate(http_requests_total[5m])) : event-based SLI (PromQL)
  • avg_over_time((… < bool 0.05)[30d:1m]) : time-slice SLI (PromQL)
  • (1 - sli:ratio_rate1h) > 14.4 * 0.001 : fast burn rate alert
  • budgetingMethod: Occurrences | Timeslices : choose the method in OpenSLO
  • sloth generate -i slo.yaml : generate Prometheus rules and alerts

Sources #

Qonto status page reading taken in November 2026; percentages change daily.

Related articles

The observability trilemma: cost, completeness and performance, and how solutions resolve it

Understanding the observability trilemma (cost, data completeness, query performance), its three trade-offs, …

Grafana administration and security: organizations, teams, RBAC, service accounts and authentication

Running Grafana in a company: organizations, teams, folders, roles and RBAC, data source permissions, service…

Dashboard engineering: state visualizations, annotations, library panels and navigation

Building professional dashboards: State timeline, Status history, Node graph, annotations, library panels, re…

Keep learning

Support us

♥ SUPPORT US

Support RousselTM Learning

Courses, articles, labs and certificates stay free with no intrusive ads. A voluntary contribution, of any amount you choose, pays for hosting, lab environments and new content.

Contribute with PayPal Any amount · card or PayPal accountLearn more
QR code PayPal
Or scan this QR code with your phone

Thank you, every contribution counts!