Strong SRE answers connect measurement to user impact. It is not enough to name a metric or recite an alerting pattern: you should be able to define what counts as a good request, explain how quickly an alert detects a meaningful reliability risk, and show how telemetry helps someone respond.
This guide focuses on a specific, often underexplained area of observability interviews: service-level objectives, error-budget policy, and actionable alert design. The questions progress from defining reliability signals to designing alerting and telemetry for a multi-service system.
For each question, start with a direct answer, then state the assumptions that make it correct. Interviewers are usually looking for that second part.
Fundamentals
1. What is the difference between an SLI, an SLO, and an SLA?
What the interviewer is really testing: Whether you can distinguish a measurement, an internal reliability target, and a customer-facing commitment.
Model answer: An SLI is a measurement of a service property users care about, such as the proportion of valid requests that succeed. An SLO is a target for that measurement over a defined window. An SLA is an external agreement that may define remedies if a commitment is missed.
For example, “99.9% of eligible requests succeed over a rolling 30-day window” is an SLO only if “eligible request,” “succeed,” and the measurement window are precisely defined. An SLA may use a similar number, but it has contractual meaning and should not be treated as interchangeable with the operational target.
Follow-up: Should an internal SLO usually be stricter than the corresponding SLA?
Hint: Consider the time needed to react before a contractual commitment is at risk.
2. How would you define an availability SLI for an API?
What the interviewer is really testing: Whether you can choose a denominator that represents user experience rather than convenient server-side counters.
Model answer: I would define the population first: requests that reached the service and were valid according to the API contract. Then I would define success from the user’s perspective, for example, an expected successful response within a specified latency bound.
A basic request-based availability SLI is:
good requests / eligible requests
The definition needs explicit treatment of client errors, cancellations, timeouts, retries, and dependency failures. A 4xx response might be a successful service outcome if the client sent an invalid request; it should not automatically count as a service failure. Conversely, a request that eventually succeeds after a long retry may still be a bad user experience. The SLI should match the question the SLO is intended to answer.
Follow-up: How would you keep a client retry from hiding a user-visible failure?
Hint: Define whether the measurement unit is an attempt, an API request, or a user journey.
3. How much error budget does a 99.9% SLO allow in a 30-day window?
What the interviewer is really testing: Whether you can do the basic budget calculation and identify its assumptions.
Model answer: A 99.9% success objective permits a 0.1% failure fraction. If the window is treated as 30 days, that is 43.2 minutes of equivalent downtime for a continuous availability measure. For a request-based SLI, the more direct interpretation is 0.1% of eligible requests may be bad.
The arithmetic is simple; choosing the right unit is not. A request-based budget does not necessarily translate cleanly into minutes, especially when traffic varies. State whether you are calculating a time-based or event-based budget.
window_minutes = 30 * 24 * 60 # Assumes a 30-day window
objective = 0.999
allowed_bad_minutes = window_minutes * (1 - objective)
print(f"{allowed_bad_minutes:.1f} minutes")
What to notice: the calculation is only meaningful after you specify the SLI and the window.
Follow-up: Why might “43.2 minutes of downtime” be misleading for a request-based SLO?
Hint: A partial outage during peak traffic can consume more request budget than the same outage during a quiet period.
4. What makes a useful SLO?
What the interviewer is really testing: Whether you can turn a vague reliability aspiration into a measurable, reviewable contract.
Model answer: A useful SLO has a user-relevant SLI, a defined population and measurement method, a time window, and an owner who can act when the target is at risk. It should be ambitious enough to represent a meaningful reliability goal but achievable enough to guide real trade-offs.
Avoid selecting a target solely because it sounds impressive. Also avoid defining an SLO around an internal component’s health if that component’s health does not reliably predict user experience. Start with a critical user journey, identify a measurable success condition, then validate that the data is trustworthy and the team can influence the outcome.
Follow-up: What would you do if a team cannot reliably measure its proposed SLI?
Hint: Treat measurement quality as work required before the target can govern decisions.
Intermediate
5. What is an error-budget burn rate?
What the interviewer is really testing: Whether you can reason about the rate of reliability consumption rather than wait for a period-end SLO result.
Model answer: Burn rate compares the observed bad-event ratio with the allowed bad-event ratio. A burn rate of 1 consumes the error budget at the rate that would exhaust it over the SLO window. A burn rate of 10 consumes it ten times faster.
For an SLO with a 0.1% allowed error ratio, an observed 1% bad-request ratio is a burn rate of 10. This is useful for alerting because it translates a recent failure rate into the pace at which the objective is being endangered. The calculation must use the same eligible population and bad-event definition as the SLI.
Follow-up: Does a high burn rate always mean users are experiencing a large absolute number of failures?
Hint: Consider the request volume and the size of the measurement window.
6. Why use multi-window, multi-burn-rate alerts instead of a single threshold?
What the interviewer is really testing: Whether you understand the trade-off between detecting a fast incident and avoiding noisy alerts.
Model answer: A short window detects a rapidly developing problem, but its result can be noisy. A longer window is more stable, but it can delay detection. A multi-window alert combines the two: require a high burn rate over a short window and confirm that a longer window also shows sustained budget consumption.
For instance, an organization might page on a very high burn rate sustained across a short and a longer window, while a lower rate sustained for longer creates a ticket. Exact thresholds depend on the SLO window, traffic, and the response the team can take. The important property is that the alert represents meaningful budget risk, not that every team copies the same numbers.
Follow-up: What could make a short-window burn-rate alert unreliable?
Hint: Examine traffic volume, missing data, and whether the longer window confirms the same impact.
7. When should an alert page a person rather than create a ticket?
What the interviewer is really testing: Whether you design alerts around urgency and actionability, not around the existence of a metric threshold.
Model answer: Page when a condition is urgent, user-impacting or likely to become so soon, and someone can take an action that may change the outcome. Use tickets or dashboards for issues that need investigation but do not require an immediate interruption.
A page should tell the responder what is affected and where to start. A CPU threshold on one instance is usually not sufficient by itself: the instance may be replaceable and users may see no impact. A sustained SLO burn, rising queue age that threatens a user-facing deadline, or loss of a critical dependency may justify a page if the team has a documented response.
| Approach | Useful for | Main risk |
|---|---|---|
| Static threshold | A known hard limit, such as a resource nearing exhaustion | Threshold may not correspond to user impact |
| Rate-of-change alert | Detecting a rapidly worsening signal | Normal bursts can look alarming |
| SLO burn-rate alert | Detecting fast consumption of reliability budget | Requires trustworthy SLI data and careful windows |
| Ticket or dashboard condition | Trends and work that can wait for business hours | Important issues may remain unattended |
Follow-up: What question should every paging alert help a responder answer?
Hint: State the user impact and the next useful investigation step.
8. How do you choose between metrics, logs, and traces when investigating an incident?
What the interviewer is really testing: Whether you understand that the three signals have different roles and should work together.
Model answer: Metrics summarize behavior across time and dimensions, which makes them effective for dashboards and alert evaluation. Logs provide event-level context and are useful when a specific failure needs explanation. Traces show the path and timing of work across service boundaries, which helps locate latency or errors in a distributed request.
I usually start with an alert or metric that identifies a symptom, narrow the affected service or operation, then use trace and log context to investigate representative requests. Trace IDs and consistent service, route, and deployment attributes help connect the signals. No signal replaces the others: a trace is not an efficient fleet-wide alert, while an aggregate metric may not explain an individual failed request.
Follow-up: Why is it risky to alert directly on the count of log messages containing “error”?
Hint: Think about duplicate events, expected errors, and changes in log wording.
Senior and system-design level
9. Design observability for a user-facing service with a dependency.
What the interviewer is really testing: Whether you can design a coherent telemetry path that supports alerting and investigation without overwhelming the team.
Model answer: Instrument the service around a user-relevant request or journey. Record request outcomes and duration as metrics; include service, operation, and bounded outcome attributes. Emit structured logs for meaningful events, with trace context where available. Create spans for the request and important dependency calls, and propagate context across service boundaries.
Keep cardinality and data sensitivity under control. Route and outcome are generally better metric dimensions than user IDs or request IDs. Put identifiers needed for individual investigation in appropriately governed traces or logs instead of creating a new time series for every request. Sampling should preserve enough information for investigation while keeping telemetry volume and cost manageable.
A practical request investigation path is:
flowchart LR Alert["SLO alert"] --> Metric["Service metric"] Metric --> Trace["Representative trace"] Trace --> Log["Correlated structured log"] Trace --> Dependency["Dependency span"]
Caption: Start from aggregate impact, then use trace context to inspect a particular request.
Follow-up: Where would you put a request identifier: a metric label, a log field, or a span attribute?
Hint: Compare query value, cardinality, privacy, and retention for each signal.
10. How do you design alerting for a low-traffic endpoint?
What the interviewer is really testing: Whether you recognize that a mathematically valid ratio can be unstable when the denominator is small.
Model answer: First, determine whether a request-based SLI has enough observations to support the intended alert window. A single failure can produce a large bad-request ratio at low volume even if the broader service is healthy. Conversely, sparse traffic can make a sustained outage hard to detect from request ratios alone.
Possible mitigations include using a longer evaluation window, adding a synthetic check for a critical journey, or defining a separate objective for a particularly important operation. A synthetic check should represent a realistic user path and be distinguished from real traffic in the measurement model. Do not silently mix synthetic and production events in a way that changes the SLO denominator.
Follow-up: What would you do if the synthetic check succeeds but real users are failing?
Hint: Compare the check’s identity, route, region, authentication, and dependency path with real requests.
11. How should SLOs work across a multi-service user journey?
What the interviewer is really testing: Whether you can reason about end-to-end reliability without making misleading assumptions about independent components.
Model answer: Define the user journey’s success at the boundary where the user experiences it, then use service-level SLOs to help teams locate and own contributing failures. A dependency’s availability is evidence for diagnosis, not necessarily a substitute for the end-to-end SLI.
Do not automatically multiply component availability targets to claim an end-to-end target. Such arithmetic assumes independence and matching measurement populations, which are often false in production. Retries, caches, fallback behavior, traffic routing, and correlated failures all change the relationship. Use the end-to-end SLI to measure the journey and supporting service SLIs to explain it.
Follow-up: When might a dependency error not count as a user-visible failure?
Hint: Consider a fallback or degraded response and whether it still meets the user’s need.
12. What would you do when the error budget is exhausted?
What the interviewer is really testing: Whether you treat an SLO as an input to engineering decisions rather than a dashboard decoration.
Model answer: First verify the signal: confirm the SLI data, the affected population, and whether the failures are still occurring. Then follow an agreed policy. That might mean prioritizing reliability work, pausing risky releases, reducing change scope, or accepting a documented exception when the business need warrants it.
The policy should not be an automatic punishment or an instruction to stop all engineering. It is a way to make risk visible and align teams on trade-offs. A useful review identifies the causes of budget loss, the actions that would prevent recurrence, and whether the current SLO remains an appropriate expression of user expectations.
Follow-up: How should a team handle an SLO that is repeatedly missed despite reliability work?
Hint: Revisit the causes, the measurement, the target, and the team’s ability to influence the outcome.
Practical observability contract
The interview answers above depend on telemetry that is consistent enough to support decisions. For a service, make the contract explicit:
- Logs: Emit structured events with stable field names. Include service, environment, operation, outcome, and trace context where available. Do not log secrets or use unbounded identifiers as metric dimensions.
- Metrics: Use RED for request-driven services: rate, errors, and duration. Use USE for resources: utilization, saturation, and errors. Keep dimensions bounded and document the meaning of each counter and histogram.
- Traces: Propagate trace context across service and dependency boundaries. Use spans for meaningful operations, not every trivial function call. Apply sampling deliberately, especially when investigating rare failures.
- Ownership: Every SLO and paging alert has a team, a runbook or investigation path, and a known data source.
A structured log event might look like this:
{
"timestamp": "2026-11-06T12:00:00Z",
"severity": "ERROR",
"service.name": "checkout",
"deployment.environment": "production",
"http.route": "/orders/{orderId}",
"event.name": "payment_authorization_failed",
"trace_id": "4bf92f3577b34da6a3ce929d0e0e4736",
"error.type": "dependency_timeout"
}
Trace IDs are useful for correlation, but they are not substitutes for stable metric labels. Log only the context responders need and that your privacy and retention policies permit.
The following Python example uses the OpenTelemetry SDK to create an in-memory trace with a parent operation and a dependency span. Install opentelemetry-api and opentelemetry-sdk first.
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
from opentelemetry.sdk.trace.export.in_memory_span_exporter import (
InMemorySpanExporter,
)
from opentelemetry.trace import Status, StatusCode
exporter = InMemorySpanExporter()
provider = TracerProvider()
provider.add_span_processor(SimpleSpanProcessor(exporter))
trace.set_tracer_provider(provider)
tracer = trace.get_tracer("checkout")
def authorize_payment(amount: float) -> str:
with tracer.start_as_current_span("checkout.authorize") as span:
span.set_attribute("service.operation", "authorize_payment")
span.set_attribute("payment.amount", amount)
with tracer.start_as_current_span("payment.authorize") as dependency:
dependency.set_attribute("peer.service", "payment-provider")
result = "approved"
dependency.set_attribute("payment.outcome", result)
span.set_status(Status(StatusCode.OK))
return result
assert authorize_payment(42.0) == "approved"
spans = exporter.get_finished_spans()
assert len(spans) == 2
assert {span.name for span in spans} == {
"checkout.authorize",
"payment.authorize",
}
provider.shutdown()
What to notice: the dependency operation is a child span, and the example asserts the exported trace structure without contacting an external service.
Use a trace backend and exporter appropriate to your deployment; keep instrumentation separate from business logic where possible. See the official OpenTelemetry Python instrumentation documentation.
A sample SLI/SLO table makes the contract reviewable:
| User-facing capability | SLI | Example objective | Primary window |
|---|---|---|---|
| API requests | Good eligible responses / eligible responses | 99.9% | Rolling 30 days |
| Interactive API latency | Eligible requests below a defined latency bound / eligible requests | 99% | Rolling 30 days |
| Critical checkout journey | Completed valid journeys / started valid journeys | Set from product requirements | Rolling 30 days |
The objective values above are examples, not universal targets. The latency bound and eligibility rules must be specified before an SLI can be implemented consistently.
Page on conditions that are both actionable and consequential:
- A sustained, high SLO burn rate that threatens the objective.
- A critical journey failing, including a confirmed synthetic failure where appropriate.
- Resource saturation that is causing or is likely to cause user-visible failures before normal intervention is possible.
- A telemetry or alerting failure that leaves a critical service without trustworthy coverage.
Create tickets or dashboard signals for trends that need investigation but do not require immediate response. Alerting guidance and examples are available in the Prometheus alerting practices documentation and the Google SRE Workbook chapter on alerting on SLOs.
Common mistakes candidates make
- Quoting an availability percentage without defining the SLI. A target is not meaningful until its eligible events and good-event condition are clear.
- Treating every non-2xx response as a service failure. Some client errors are correct service behavior; some successful responses still violate a latency or usability requirement.
- Using a single noisy threshold as a page. Explain why the threshold indicates user impact and why a responder should act now.
- Confusing a dependency’s health with the user’s experience. Measure the journey at its boundary, then use component signals for diagnosis.
- Ignoring denominator size. A ratio based on a handful of requests can be volatile; show how you would validate or supplement it.
- Putting unbounded IDs on metrics. High-cardinality labels can make a telemetry system costly or unusable. Keep per-request detail in suitable logs or traces.
- Claiming a universal burn-rate threshold. Thresholds depend on the objective, window, traffic, and response model. Explain the design, not just a memorized number.
- Treating error-budget exhaustion as a punishment. It is a trigger for an explicit risk discussion and prioritization policy, not a substitute for engineering judgment.
Quick-revision checklist
Before an interview, make sure you can explain:
- The difference between an SLI, an SLO, and an SLA.
- How you define eligible events, good events, and the measurement window.
- How error-budget arithmetic differs for time-based and request-based SLIs.
- Why burn rate is useful and how multiple windows reduce noisy paging.
- What makes a page actionable, urgent, and tied to user impact.
- How metrics, logs, and traces complement one another.
- The RED signals for services and USE signals for resources.
- How low traffic, retries, fallbacks, and dependencies affect SLO interpretation.
- How to keep metric cardinality and sensitive telemetry under control.
- What the team does when an SLO is at risk or its budget is exhausted.
This article was generated with AI. #AIGenerated