What SRE as a service means
SRE as a service is a retainer under which an external team takes shared responsibility for a system’s reliability: it agrees service level objectives with you, watches error budgets, carries the on-call pager for an agreed window, runs incidents, writes postmortems and spends reserved engineering time removing the causes and the toil. It differs from managed services, which keep systems running to a ticket SLA, because the provider is measured on your users’ experience and is expected to change the system, not just operate it.
Most “SRE as a service” offers are on-call with a new name. Here is how to tell the difference
Page one for this query is mostly vendor pages that list the same words (SLOs, observability, incident response) without saying what the monthly fee buys. The useful questions are commercial. How many engineering hours are in the fee, and how many of them go to fixing things rather than answering pages? Which hours of the day does the pager cover, and how fast must someone respond? Whose number is the SLO, and what happens when the error budget runs out? What do you keep if you end the contract?
This page answers those questions for the way we sell it, and gives you a checklist to use with any provider. The practice itself, defining indicators, instrumenting with OpenTelemetry and redesigning alerts, is described on our SRE and observability page. If what you need is someone to patch servers and restore backups under a ticket SLA, our managed services are the better fit, and for AWS-specific operations in India see our AWS managed services guide.
Radiatus is an engineering studio registered as an MSME in India and in Delaware, USA. Our engineers work from India, which matters for one reason above all: for teams in the Americas and much of Europe, your night falls in our working day.
SRE as a service, managed services, staff augmentation or your own team?
Four models get sold under overlapping names. They differ in who owns the reliability target and who is allowed to change the system.
| Model | Measured on | Carries the pager | Changes code and infrastructure | Typical failure |
|---|---|---|---|---|
| SRE as a service | SLOs on user journeys, error-budget burn, postmortem actions closed | Provider, for an agreed window | Yes, through your review process | Engineering hours quietly consumed by interrupts |
| Managed services | Ticket response and resolution times, patch and backup compliance | Provider | Infrastructure only, rarely application code | Systems kept running, causes never removed |
| Staff augmentation | Whatever your manager sets | Your rota, which they join | Yes, as your team member | One person becomes a single point of failure |
| In-house SRE team | Your own objectives | Your team | Yes | Too few people for a sustainable 24/7 rota |
A sustainable round-the-clock rota needs enough people that nobody is on call too often, which is why small companies rarely staff it themselves. A retainer shares one rota across clients, but that is also its risk: ask how many systems the person holding your pager also covers.
Example tiers to agree, sized in engineer-days
We have not published fixed tiers or response numbers, because the right figures depend on your architecture, how much you let us change and how noisy your alerts are on day one. The table shows the shapes we propose and the response targets we would expect to agree. Treat every figure here as an example for discussion; the binding numbers are the ones written into the contract after onboarding.
| Business hours | Extended | Round the clock | |
|---|---|---|---|
| Engineering capacity | About 4–6 engineer-days a month | About 8–12 engineer-days a month | About 12–20 engineer-days a month, plus the on-call rota |
| On-call window | Indian working day, Monday to Friday | Two Indian shifts, about 16 hours on weekdays; weekend pages next morning | 24 hours, 7 days |
| Example Sev 1 target (users cannot use a core journey) | Acknowledge within 30 minutes in window | Acknowledge within 15–30 minutes in window | Acknowledge within 15 minutes, any time |
| Example Sev 2 target (degraded, workaround exists) | Within 2 working hours | Within 1 hour in window | Within 1 hour, any time |
| Example Sev 3 (no user impact yet) | Next working day | Next working day | Next working day |
| SLOs under watch | 2–3 user journeys | Up to about 6 | Agreed per service |
| Reviews | Monthly reliability report | Monthly report and review call | Monthly review, quarterly SLO review with product owners |
| Suits | Teams in Asia, the Gulf or Europe with few night incidents | Teams in Europe or the Americas wanting their night covered | Revenue or clinical systems that must be watched every hour |
“Acknowledge” means a named engineer has the incident and has posted a first assessment, not that a bot replied. Ask any provider for the same distinction. Resolution times are not promised in any tier, because they depend on causes outside the provider’s control; what is promised is the response, the communication rhythm and the follow-up.
What other providers publish: one price reference
Few SRE-as-a-service providers publish prices. Palark’s pricing page does, and it is a useful benchmark for the shape of an offer. As of 13 November 2026 it lists SRE as a Service at €9,100 a month for 120 team hours (M), €11,700 for 160 hours (L) and €14,300 for 200 hours (XL), each with 24/7 on-call, unlimited incidents and a 10-minute reaction-time SLA, and an application uptime SLA that is “TBD after 3 months”. Its DevOps as a Service tiers, €3,200 for 40 hours and €6,200 for 80 hours, cover 8×5 rather than 24/7. That works out at roughly €71–76 per team hour at the SRE tiers. Two things in that offer are worth copying whatever you buy: hours are stated in the price, and the uptime commitment waits until the provider has seen the system for three months.
We quote in engineer-days per month after onboarding, not from a public price list, and we tell you how many of those days we expect to go to engineering rather than response.
How SLOs and error budgets go into the contract
A provider cannot promise your uptime for a system it does not control. What a contract can do is define how reliability is measured and what both sides do when it slips. Write down five things:
- The indicator. The exact query, the data source and what counts as good. “Share of booking API requests that return non-5xx in under 800 ms, measured at the load balancer” is checkable; “the site is up” is not.
- The objective and window. For example 99.9% over a rolling 28 or 30 days.
- The error-budget policy. Google’s example policy halts changes other than P0 and security fixes while a service is over budget, and requires a postmortem with at least one P0 action for any single incident that uses more than 20% of the four-week budget. Your policy can be softer, but it must say who decides.
- Exclusions. Planned maintenance, a cloud provider’s regional outage, load tests, traffic from clients outside the agreement.
- Who changes the objective. Usually a quarterly review with product owners, never mid-incident.
The arithmetic of a 30-day window, so everyone sees what a target allows:
| Objective | Error budget over 30 days | What that usually implies |
|---|---|---|
| 99% | 7 hours 12 minutes | Business-hours cover can be enough |
| 99.5% | 3 hours 36 minutes | Night pages for core journeys |
| 99.9% | 43 minutes 12 seconds | Round-the-clock on-call and fast rollback |
| 99.95% | 21 minutes 36 seconds | Automated failover; humans too slow for most faults |
| 99.99% | 4 minutes 19 seconds | Redundancy across zones or regions, designed in |
Keep the objective as code next to your services. An example in the format used by Sloth, which generates Prometheus recording and alerting rules from it:
version: "prometheus/v1"
service: "booking-api"
labels:
owner: "sre-retainer"
slos:
- name: "requests-availability"
objective: 99.9
description: "Booking API requests answered without a 5xx."
sli:
events:
error_query: sum(rate(http_requests_total{job="booking-api",code=~"5.."}[{{.window}}]))
total_query: sum(rate(http_requests_total{job="booking-api"}[{{.window}}]))
alerting:
name: BookingApiErrorBudgetBurn
page_alert:
labels:
severity: page
ticket_alert:
labels:
severity: ticket
Generated alerts follow the multi-window, multi-burn-rate method from Google’s SRE workbook: page when the budget is burning 14.4 times too fast over an hour (and over the last five minutes), or 6 times over six hours; open a ticket at a steady 1 times over three days. That one change usually removes most CPU and disk pages that never meant a user was affected.
On-call: write down what the provider may do without asking
Most on-call friction between a company and an outside SRE team comes from one gap: nobody agreed which actions are pre-approved. Settle it in a table before the first shift.
| Pre-approved during an incident | Needs your on-call contact’s approval | Never without a change request |
|---|---|---|
| Restart a process or pod; scale out within agreed limits; roll back the most recent deploy; fail over to a standby; switch on a documented feature flag | Scale beyond the cost limit; fail over across regions; block a customer or IP range; disable a scheduled job | Data fixes or deletions; database schema changes; changes to security groups, IAM or encryption keys |
Pair that with access rules: personal accounts with multi-factor sign-in, elevated access granted for the incident and expiring after it, and session logging your security team can read. Shared admin passwords end the conversation.
Check your paging tool too. Atlassian stopped selling Opsgenie on 4 June 2025 and ends support on 5 April 2027, and Grafana OnCall’s open-source edition was archived on 24 March 2026. If your rota runs on either, moving it is part of onboarding, and a good moment to rebuild escalation policies from scratch.
Follow-the-sun from India: which of your night hours we cover awake
India runs on IST, UTC+5:30, with no daylight saving. Rather than overlap for meetings, the question for on-call is which hours of your night fall inside an Indian working day:
- US East Coast: 9 p.m. to 7 a.m. Eastern in winter is 7:30 a.m. to 5:30 p.m. IST. The whole of your night sits in our day shift.
- US West Coast: 9 p.m. to 7 a.m. Pacific in winter is 10:30 a.m. to 8:30 p.m. IST, again inside a normal day plus an evening shift.
- UK: 10 p.m. to 7 a.m. GMT is 3:30 a.m. to 12:30 p.m. IST. A morning shift from 7 a.m. IST covers the second half of your night; the first half needs a night shift or your own rota.
- Gulf and Singapore: your night is our night too. Round-the-clock cover from India for these zones is a genuine night shift, priced accordingly.
The handover between shifts is where incidents get dropped. Each one should be a written note in the incident channel with four lines: incidents open and who owns them, error budgets burning faster than normal, changes in flight or scheduled, and anything the next shift must not do.
Runbooks: one per alert, tested
An alert without a runbook is a question sent to a sleepy engineer. Every paging alert gets one, kept in your repository and linked from the alert itself:
# BookingApiErrorBudgetBurn
Meaning: booking API 5xx rate is using the monthly error budget too fast
User impact: patients cannot complete online bookings
First checks:
1. Deploys in the last 2 hours? (pipeline history)
2. Database connections saturated? (dashboard: booking-db)
3. Upstream payment or SMS provider status page
Safe actions: roll back last deploy; scale booking-api to 6 replicas
Escalate: to your on-call contact if no improvement in 20 minutes
Last tested: 2026-10-14 (game day)
We test runbooks in game days, deliberately breaking a staging copy, and any step that failed or confused someone is fixed before the runbook is marked tested.
Postmortems that change the system
Agree in the contract when a postmortem is due (for example, every Sev 1 and any incident that used more than a fifth of the monthly budget), how soon a draft follows the incident, and who reviews it. The format matters less than three rules: the timeline is built from logs and chat, not memory; the causes describe conditions, not people; and every action item has an owner, a date and a ticket. The number that tells you whether a retainer is working is not the count of postmortems written. It is the share of their action items closed by the due date, reported every month.
Toil: count it, cap it, spend the rest fixing
Google’s SRE book defines toil as work that is manual, repetitive, automatable, tactical, has no enduring value and grows with the service, and states a goal of keeping it below 50% of each SRE’s time. The same principle belongs in a retainer. We tag every hour as either interrupt (pages, tickets, requests) or engineering (automation, alert fixes, capacity work, postmortem actions) and show the split in the monthly report. If interrupts take more than half of the retained days for two months running, that is a finding, and the review decides whether to fix the noisiest sources first or change the tier.
Exit and handover
A provider you cannot leave is a risk, whatever its response times. Write exit into the first contract:
- Everything lives in your accounts. Alert rules, SLO definitions, dashboards and runbooks as code in your repositories; postmortems in your wiki; tickets in your tracker.
- A notice period and a handover window. For example 30 days’ notice and two weeks of shadow on-call, with your team or the new provider holding the pager and ours as second line.
- An access list. Every account, key and integration the provider holds, maintained monthly, so revocation on the last day is a checklist rather than an investigation.
- Credential rotation. Any shared secret the provider could see is rotated after exit.
Questions to ask any SRE as a service provider
- How many engineering hours are in the fee, and what share went to engineering rather than interrupts for your current clients last quarter?
- How many systems does the engineer holding our pager also cover at night?
- Do your response targets mean a human acknowledgment with a first assessment?
- Whose SLOs are these, how are they measured, and what happens when the budget is spent?
- What may your on-call engineer do without asking us?
- When is a postmortem due, and how do you report the action items closed?
- What do we keep, and how long is the handover, if we leave?
SRE as a service: how we package it
Sized in engineer-days. Figures are typical; we fix the retainer after the onboarding baseline, when we know how noisy the system is.
Reliability baseline (onboarding)
The problem
You want an outside team on call, but nobody can say what “reliable” means for your system or how noisy its alerts are.
How we do it
We review recent incidents, alert volume and existing dashboards, agree two to six user journeys, write their indicators and objectives, rebuild paging alerts as burn-rate alerts, and write a runbook for each. Typical effort: 6–12 engineer-days, once.
What you get
- SLO specification as code
- Alert inventory with keep, fix or delete for each
- Runbook per paging alert
- Proposed tier and on-call permissions table
Business-hours or extended retainer
The problem
Most incidents happen in working hours, or your night falls in the Indian day, and you need engineering time more than night cover.
How we do it
Pager held for the agreed window, incidents run and written up, monthly reliability report with the interrupt and engineering split, and reserved days spent on the backlog of causes. Typical size: 4–12 engineer-days a month.
What you get
- On-call for the agreed window
- Postmortems with tracked actions
- Monthly report: SLOs, budget, toil split
- Engineering backlog worked every month
Round-the-clock retainer
The problem
The system earns money or supports care every hour, and your team cannot staff a fair 24/7 rota.
How we do it
Everything in the extended retainer, plus a 24/7 rota with documented handovers, quarterly SLO reviews with product owners and game days to test runbooks. Typical size: 12–20 engineer-days a month plus the rota.
What you get
- 24/7 on-call with written handovers
- Quarterly SLO and error-budget review
- Game day each quarter
- Access list maintained monthly
Handover to your own team
The problem
You are building an internal SRE function and want to take the pager back without a dip in cover.
How we do it
Shadow and reverse-shadow shifts, runbook walk-throughs, ownership of SLO reviews moved to your staff, and access revoked on a checklist. Typical effort: 5–10 engineer-days over two to four weeks.
What you get
- Shadow on-call schedule
- Runbook and dashboard walk-throughs
- Ownership map per service
- Access revocation record
Tools we run SRE retainers on
Vendor-neutral. We work in what you already pay for and only suggest changes where a tool blocks the work.
Prometheus, Grafana, Sloth
SLO definitions as code, generated burn-rate alerts, dashboards per user journey.
OpenTelemetry, Grafana Tempo and Loki, cloud-native logging
Follow a request across services; logs with request IDs that match traces.
Datadog, New Relic, Grafana Cloud
Used where you already have them; we tune alerting and cost rather than migrating.
PagerDuty, Jira Service Management, Grafana Cloud IRM
Escalation policies rebuilt at onboarding; Opsgenie users planned off before April 2027.
Terraform, Kubernetes, AWS, Azure, Google Cloud
Changes go through your pull-request review like any engineer’s.
Markdown in your repository, your wiki and tracker
Nothing stays in a provider-only system.
Facts, versions and vendor details checked 13 November 2026 against Palark’s published pricing, Atlassian and Grafana announcements and Google’s SRE book and workbook.
How an SRE retainer starts
From signature to a full rota in about a month. Nobody takes your pager on day one.
Access and listening
Read-only access, incident history and alert export; interviews with whoever holds the pager today.
Baseline
User journeys and SLOs agreed, alerts rebuilt as burn-rate alerts, runbooks written, permissions table signed.
Shadow on-call
We shadow your rota: we see every page and act only when asked.
Reverse shadow
We hold the pager with your engineer as backup; handovers practised.
Retainer
Full on-call for the agreed window, monthly report and review, engineering backlog worked.
Monitoring we run in our own products
Two of our products watch other systems. They are where our alerting habits come from; neither is an SRE service on its own.
Radiatus OneHealth
Certified OpenEMR plus 25 practice modules, with nothing to migrate Radiatus OneHealth includes an engine-monitoring module for healthcare integration engines (Open Integration Engine, BridgeLink and Mirth Connect up to 4.5.2). It checks four alert metrics every two minutes, the kind of narrow, symptom-based alerting we set up for retainer clients. Visit openemr.radiatus.com
CloudMonitor
See your entire cloud, clearly — multi-cloud cost, security & inventory CloudMonitor keeps an inventory of AWS, Azure and Google Cloud resources and runs 17 security checks. Its anomaly detection shows on the dashboard rather than paging anyone, and it does not yet report Google Cloud spend; we say so because those limits shape how we use it. Visit cloud-monitor.radiatus.comGuides and related pages
Guides
Questions about SRE as a service
A retainer under which an external team shares responsibility for a system’s reliability: it agrees service level objectives, watches error budgets, holds the pager for an agreed window, runs incidents and postmortems, and spends reserved engineering time removing causes and toil. Managed services, by contrast, usually keep systems running to a ticket SLA without changing them.
It depends on engineering hours and the on-call window. For reference, Palark publishes SRE as a Service at 9,100 to 14,300 euros a month for 120 to 200 team hours with 24/7 on-call, as of 13 November 2026. We size retainers in engineer-days a month after an onboarding baseline, typically 4 to 12 days for business-hours or extended cover and 12 to 20 plus the rota for round-the-clock.
Response, not resolution. A reasonable starting point to negotiate is a human acknowledgment with a first assessment within 15 minutes for a severity-one incident in a 24/7 tier, and within an hour for degraded service. The binding numbers belong in the contract and should be reviewed after the first quarter, once alert noise is known.
Not honestly at the start, because it does not control your code, your releases or your cloud provider. What it can commit to is how reliability is measured, how fast it responds and what happens when the error budget is spent. Some providers set an uptime commitment only after observing the system for a few months.
India is on UTC+5:30 with no daylight saving, so a US East Coast night falls almost exactly in an Indian day shift and a West Coast night in a day plus evening shift. Engineers handle your night pages awake. For the UK, a morning shift covers the second half of your night; Gulf and Singapore nights are Indian nights too and need a true night rota.
You do. They should live as code in your repositories, your wiki and your tracker from the first day, so that ending the contract means revoking access, not recovering documents. Ask any provider to put this in writing.
Whatever your written error-budget policy says. A common pattern, from Google’s published example, is to pause feature releases except urgent and security fixes until the service is back within its objective, and to require a postmortem for any single incident that used more than a fifth of the budget.
Give the agreed notice, then run a handover window, typically two weeks of shadow on-call where your team or the new provider holds the pager and the outgoing team is second line. Close by revoking every account on the maintained access list and rotating any shared secrets.
Want someone else holding the pager, with the terms written down?
Tell us what you run, where your users are, how many pages you get in a typical week and who answers them now. A senior engineer will reply with a proposed baseline, and we can talk it through on a free 30-minute call.





Compliance-first delivery