DevOps and Site Reliability Engineering (SRE) work together. DevOps joins development and operations in one delivery practice. SRE adds engineering methods and measurable reliability targets. Start by naming who owns releases, incidents, on-call coverage, and permanent fixes. Add a dedicated SRE function when service complexity and incident load call for specialists. Smaller teams can apply the same practices without a separate department.
Where DevOps and SRE Overlap
DevOps describes how people develop, deliver, and operate software together, with automated delivery and feedback between development and operations. SRE keeps services reliable through measurable objectives, automation, structured incident response, and engineering that removes recurring operational work. Both aim for safe changes and less operational friction.
The two practices coexist. In Google’s SRE Workbook, SRE is presented as a concrete way to implement several DevOps principles. In both, the engineers who ship changes can also be the ones who respond to production incidents.
Take a team where product engineers maintain the application and deploy its changes. The same engineers set a reliability objective, join on-call rotations, and automate recovery procedures. That team uses SRE methods without a department of that name.
An SRE also writes production code, builds deployment automation, improves observability, and takes part in software architecture.
Define the terms internally before you compare structures. Some companies use DevOps for engineering practices and others for a team or job title. SRE likewise means a discipline, a specialist role, or an organizational function.
Who Owns Releases, Incidents, and Permanent Fixes?
Every production service needs named owners for deployment, detection, response, recovery, and follow-up. Each needs a primary owner, a realistic backup, and the authority to act.
Take an application where developers own the code, a platform team runs shared infrastructure, and an SRE specialist advises on reliability. In a smaller company, the same people often fill all three roles.
| Production duty | Example primary responsibility | What the owner needs |
|---|---|---|
| Build and test changes | Product/application engineers | Access to the delivery pipeline and test results |
| Approve and deploy releases | Designated release owner | Defined release and rollback permissions |
| Maintain service objectives and SLIs | Accountable service owner, advised by SRE where available | Agreement on SLO targets, measurement windows and review authority |
| Observe customer-facing behavior | Service owner and monitoring responders | Access to relevant SLIs and service telemetry |
| Maintain paging rules | Owner of monitoring configuration, with input from responders | Permission to tune thresholds and a route for urgent alert changes |
| Receive the initial page | Named primary on-call responder | Reachable secondary responder |
| Coordinate a major incident | Designated incident lead, when the process requires one | Escalation and communication authority |
| Mitigate or roll back | Responder with application or platform support | Ability to restore service or reach someone who can |
| Repair the underlying cause | Team owning the affected code or configuration | Prioritized engineering work and change permissions |
| Review the incident | Incident participants and accountable service owner | Assigned follow-up actions |
| Eliminate repeat incidents | Responsible application or infrastructure team, supported by reliability expertise | Tracked completion of durable improvements |
The critical handoff is between the person who receives the alert and the person who can change the system. A responder with no rollback access, no useful runbook, and no reachable application owner has little chance of restoring the service.
Fill the matrix for one production service with real people or teams. Name the primary and secondary responders, who holds release and rollback permissions, who has escalation authority, who owns the SLO and alert-rule changes, and who owns the permanent fix.
Had an interesting conversation with my new boss today that I’d love to get some perspective on. I work on a two person devops team supporting an application used by some fairly large players in the transportation industry in a critical role. This is an application that has SLAs with associated financial penalties and to be honest our customers, I think, expect that we have more invested in our operational capabilities than we actually do considering how little revenue we make a year from the whole thing. Currently, myself and a junior engineer split an on call rotation that I set up ‘voluntarily’. Previously, our alerts were just coming in to emails or SNS, which wasn’t effective obviously, and so not having an easy way to get phone alerts I setup a free pager duty account. Thus began our 26 weeks each of ‘official’ on-call a year for which I am the escalation point so functionally speaking i’m on call 24/7/365 for the last few years.
Two engineers carry a service with SLAs and financial penalties, and the escalation contact is effectively on call all year.
The same contributor describes an incident after a Jasper Reporting Server update. Users could not generate reports for roughly three hours, and a support ticket exposed the problem before monitoring alerted the team.
A small team can run operations itself, even for an important service, as long as it can carry the load. When customer impact and coverage demands exceed what the rotation supports, you need more people, more skills, or a different split of work. Renaming a role to SRE changes none of that.
What DORA Metrics and SLOs Measure
Delivery speed and service reliability answer different questions. A team can deploy faster and still have reliability problems, and a service can degrade with no recent deployment.
SRE describes reliability with four related terms:
- Service-level indicator (SLI): A measurement of service behavior, such as request success or customer-observed latency.
- Service-level objective (SLO): A chosen target for an SLI over a defined measurement period.
- Service-level agreement (SLA): A service commitment made to an external party, potentially with contractual consequences.
- Error budget: The amount of unreliability tolerated by an SLO over its measurement period.
An error budget gives teams a way to weigh service risk against shipping changes. You can use it to decide whether to keep releasing, focus on reliability work, or investigate recurring failures. Google discusses this approach in its Embracing Risk chapter. Choose the target and release policy for the specific service and its users.
DORA covers delivery. Its software-delivery performance framework defines five metrics in the DORA metrics guide, grouped around delivery throughput and deployment instability, with separate measures for failed changes and unplanned corrective deployments.
| Measurement | Question it helps answer |
|---|---|
| Change lead time | How long does a software change take to reach production? |
| Deployment frequency | How often does this application or service deploy changes? |
| Failed deployment recovery time | How quickly does the service recover from a failed deployment? |
| Change fail rate | What share of deployments require immediate corrective intervention such as a rollback or hotfix? |
| Deployment rework rate | What share of deployments are unplanned changes made in response to production incidents? |
Say a deployment introduces a defect and the application team rolls it back quickly. The failed deployment and its recovery belong in the delivery metrics. Customer impact still has to be judged against the service indicators and objectives.
Now take a backend service that slows down because of an operational problem unrelated to a release. Deployment statistics stay the same while customers see degraded service. Only the reliability signals expose that problem.
When On-Call Work Becomes Toil
On-call becomes an engineering problem when repetitive interruptions eat time and never fix the system that causes them. Ask four questions: is the alert actionable, is a customer affected, does the responder have authority to act, and how much planned engineering work does it displace?
In Google’s SRE terminology, toil is repetitive, automatable operational work that grows with service demand. Google counts pager-response work as toil, even when immediate intervention is necessary. Engineering projects that automate recovery or remove recurring causes produce lasting improvements.
Google’s SRE model aims to keep operational work to at most 50% of SRE time, preserving capacity for engineering improvements. That target is specific to Google.
A pager should give the responder a clear reason to act. The signal needs enough context to show likely urgency, the affected service behavior, and the available response or escalation path.
A junior SRE described receiving 100 alerts in one on-call week, with individual application load balancer 5xx errors each generating an alert. The same contributor reported uncertainty about the system and pressure to finish scheduled project work.
Another engineer described a sharper split between the people who set the alarms and the people who answer them.
My on call rotation goes like this. On call for a week at a time, rotating between two other people, so on call every 3 weeks. Already kinda shitty as it is, but whatever. We get ~80 page outs per week, not even joking. 99% of which are false alarms for a p90 latency spike for an http endpoint, or an unusually high IOPS for a DB. I’ve tried bringing this up, and everyone seems to agree its absolutely insane, but we MUST have these alarms, set by SRE. It seems absolutely ludicrous. If I don’t wake up to answer the page within 5 min, and confirm that its just a false alarm it escalates. And they happen MULTIPLE times a night. We do have stories to work on them, but they are either 1. Not a priority at the moment, or 2. would require a major refactor in one of our backend API’s, as there are a number of endpoints seeing the latency spikes.
| Observed symptom | What to distinguish | Sustainable response |
|---|---|---|
| Many pages for individual application errors | Is there urgent customer impact or a meaningful service-level threat? | Align paging conditions with impact and required response |
| Repeated latency or database alerts | Is one cause producing recurring symptoms? | Assign investigation and durable correction to an owner who can act, and group alerts that share a cause |
| Responder cannot change alert settings | Who controls monitoring rules, and who owns the affected code? | Establish a shared change path for thresholds and remediation |
| Incident handling repeatedly displaces project work | Is the workload recurring, automatable, or beyond available coverage? | Prioritize automation, improved runbooks, mentoring, or capacity changes |
To see where monitoring changes, code fixes, or staffing would cut interruptions, classify each page in a representative period by user impact, required action, responder authority, repeated cause, and engineering time consumed.
Shared Ownership, Embedded SRE, or a Dedicated Team?
You can organize reliability work in three ways: keep it with product teams, embed or share reliability specialists, or build a distinct SRE function. Each trades expertise, coordination, and operational coverage differently.
| Operating model | Suitable situation | Main advantage | Main risk |
|---|---|---|---|
| Shared product-team ownership | Workload and coverage can be managed by the engineers who build the service | Direct access to application knowledge and fixes | Inadequate backup or specialist depth |
| Embedded or shared SRE expertise | Several services need reliability methods or specialized support | Expertise reaches product teams while they retain ownership | Specialist becomes a bottleneck or informal universal escalation contact |
| Dedicated SRE function | Reliability complexity and incident coverage require sustained specialized engineering | Concentrated operational expertise and consistency across services | Extra handoffs and the possibility of a permanent ticket queue |
In the shared model, application engineers take part in deployment, production response, and improvement work. Platform or infrastructure engineers maintain common tools, while the product team stays accountable for its service. To compare identity boundaries, recovery objectives, and network routes, use the cloud architecture workload assessment.
This works when the team has the technical skills, manageable service demands, and real backup arrangements.
An embedded specialist helps a product team set SLOs, improve observability, build recovery automation, and learn from recurring failures. The contribution lasts when knowledge and responsibility move into the service team’s own work.
A dedicated SRE function fits when several services have significant reliability demands, specialist knowledge is required, or existing arrangements cannot cover incidents. Define its relationship with the teams that develop and change the software. Before changing uptime alerts, incident response, or restore tests, check the website reliability diagnosis and recovery playbook.
Centralization has a cost. If the SRE group receives every incident while product teams disengage from production problems, the specialists collect work without the authority to remove its causes.
Platform engineering sits alongside these models. It usually covers shared developer infrastructure, standardized delivery workflows, and internal self-service. Those capabilities help developers and SREs, but service reliability still needs an explicit owner.
Judge the choice against five criteria:
- Service criticality: The consequences for users and contractual commitments when the service fails.
- Technical complexity: The depth of knowledge needed to operate, recover, and improve it.
- Coverage capacity: Whether primary and backup responders can cover the required availability.
- Authority to fix: Whether the people handling failures can ship permanent fixes or get them shipped.
- Engineering capacity: Whether enough time remains to reduce recurring operational work.
What an SRE Job Title Leaves Unsaid
The daily work behind an SRE title includes software development, automation, observability, incident response, and infrastructure improvement. What differs between roles is the mix of planned engineering and reactive work, and the authority to improve the systems you support.
A contributor to r/sre held a backend engineering position at a cloud provider that already covered CI/CD pipelines, credential rotation, database failover automation, operational tooling, monitoring, disaster recovery, and on-call. An offer for a senior SRE position left them unsure how much engineering the new job would involve.
The SRE team I’ve spoken to sounds great – broad scope, “we’ll give anything a go” mindset, mix of ops, automation, monitoring, and architecture. I want to find out if they’re painting a nice picture to convince me to join, or if SRE actually is a nice mix of things. My current colleagues have a bleaker view: they say most SRE roles are basically constant firefighting, drowning in page alerts, and being on-call 24/7. What’s the reality in your experience? Is it balanced work across automation, monitoring, and ops? Is it mostly pager duty and incident response with no breathing room? Is it no ops at all, and instead purely reliability architecture/design work? How do you split your time?
A role can advertise architecture and automation while most of the day goes to pager response. Incident work still leads to lasting improvements when the responder has the time and authority to remove recurring problems.
Check the operating evidence before you accept: the recent on-call rota, incident workload, planned engineering allocation, escalation expectations, runbook quality, source-code permissions, and control over alert rules. Also find out who decides whether recurring reliability problems get time on the engineering backlog, and ask the team to show how its recent workload and commitments match the advertised role.
Decide for One Service and Review the Result
Review the operating structure over a period that suits the service, such as 90 days. Compare customer-facing SLO results, delivery measures, alert actionability, responder coverage, and completed fixes for recurring incidents. Let those results confirm the model you chose or show that you need a dedicated SRE function.