Blog
SRE vs DevOps: the difference, and what your software needs
SRE vs DevOps from the sources that defined them: what each one is, how the two fit together, and which habits a small team running live software can borrow.
DevOps is a way of working that joins the people who build software with the people who run it, so that changes reach users faster and break less often. Site reliability engineering (SRE) is a specific discipline that came out of Google: engineers run production systems against written reliability targets, and treat operations work as something to be engineered away. Google’s own SRE workbook sums up the relationship as “class SRE implements interface DevOps”. DevOps names the goals, and SRE is one concrete way of meeting them. This guide sets out what each term means in the sources that defined them, where they differ, and which of their habits are worth adopting when you have live software but no reliability team.
What is DevOps?
AWS describes DevOps as “the combination of cultural philosophies, practices, and tools” that lets an organization ship applications and services at speed. Nobody owns the word, so definitions vary from one vendor to the next. The chapter of Google’s SRE workbook that compares the two lists five ideas DevOps is built on:
- No more silos. Development and operations stop being separate teams that hand work over a wall.
- Accidents are normal. Failures will happen, so the effort goes into recovering from them, not into finding someone to blame.
- Change should be gradual. Small, frequent releases are easier to check and easier to undo than large, rare ones.
- Tooling and culture are interrelated. Automation helps only if the people using it work in the way it assumes.
- Measurement is crucial. Decisions about the process rest on numbers the team collects.
In day-to-day terms, DevOps shows up as build and release pipelines, automated tests that run on every change, environments that can be recreated from code, and a team that watches what its own releases do in production. Its results are usually measured with DORA’s software delivery metrics: change lead time, deployment frequency and failed deployment recovery time for throughput, change fail rate and deployment rework rate for instability. The five are set out in a table, with notes on reading them, in our post on how to build a software development team.
What does SRE mean in software development?
SRE stands for site reliability engineering. The phrase comes from Google, and the introduction to its SRE book gives the shortest description: “SRE is what happens when you ask a software engineer to design an operations team.” Instead of running systems by hand, the team writes software that runs them, and holds itself to a set of rules that keep reliability measurable.
Targets written from the user’s side
Each service gets a service level indicator, which the SRE book’s chapter on service level objectives calls a carefully defined quantitative measure of the level of service, and a service level objective, a target value for that indicator. A typical pair: the share of checkout requests that succeed, with a target of 99.9% over four weeks. The book’s introduction is blunt about the target itself: “100% is the wrong reliability target for basically everything.” Its reasoning is that no user can tell a service that is available 100% of the time from one that is available 99.999% of the time, so the effort spent on that last gap buys nothing a user would notice.
An error budget
The gap between the target and 100% is the error budget. In the SRE workbook’s own example, a service with a 99.9% success target that receives 3 million requests over four weeks has a budget of 3,000 failed requests. Measured in time over a 28-day window, the same target allows a little over 40 minutes of failure. While budget remains, the team ships features. When it runs out, the policy agreed in advance takes over. The workbook’s examples include giving top priority to reliability bugs from the past four weeks, working only on reliability until the service is back within its target, and a production freeze that stops certain changes until there is budget again.

The point of the budget is that it settles an argument that otherwise never ends. Product people want releases and operations people want stability; the budget turns that into a number both sides agreed on before anything broke.
A cap on toil
Google’s chapter on eliminating toil defines toil as work tied to running a production service that is manual, repetitive, automatable and tactical, has no enduring value, and grows linearly as the service grows. Restarting a stuck job by hand every morning is toil. Google’s stated goal is to keep it below 50% of each SRE’s time, so that at least half goes on engineering work that removes the need for the toil.
Alerts that someone can act on
The book’s chapter on monitoring distributed systems names four signals to watch on any user-facing system: latency, traffic, errors and saturation. It also sets a rule for paging an engineer: “Every page should be actionable.” An alert that nobody needs to do anything about trains people to ignore alerts, including the one that matters.
Postmortems without blame
After a serious incident, SRE teams write a postmortem. Google’s chapter on postmortem culture describes it as blameless: it sets out what contributed to the incident and does not accuse any person or team of bad behavior. The chapter’s triggers for writing one include downtime or degradation that users could see beyond an agreed threshold, data loss of any kind, an on-call engineer having to step in (a rollback, rerouting traffic), a resolution time above a threshold, and a failure of the monitoring itself.
SRE vs DevOps, side by side
| Question | DevOps | SRE |
|---|---|---|
| What it is | A set of ideas and practices about how software is built and released | A defined engineering discipline for running production services |
| Where it came from | Practitioners, with no single author | Google, which set it out in its SRE books |
| Scope | The whole path from an idea to running code | Services in production and the people who use them |
| What it measures | How fast and how safely changes are delivered | Whether each service meets its reliability target |
| How it decides between speed and stability | Small releases, automation and shared ownership | An error budget with a policy agreed in advance |
| Who does it | Usually the whole product team, often with a platform or DevOps engineer | Usually a dedicated SRE team, or engineers given the role |
The workbook’s own comparison makes the same point in fewer words: SRE has narrower, more defined responsibilities than DevOps, and brings a more opinionated framework to running systems. It does not present the two as rivals. The introduction to the earlier SRE book goes further and says DevOps can be viewed as “a generalization of several core SRE principles”.
Is SRE replacing DevOps?
No. They answer different questions, so one cannot replace the other. A company can work in a DevOps way without ever having an SRE team, and an SRE team works inside a delivery process that is usually built on DevOps ideas. In job ads the two titles are often used loosely, which is where most of the confusion starts.
DevOps engineer vs site reliability engineer
As job titles, a DevOps engineer usually owns the pipelines, environments and infrastructure code that let a team release, and a site reliability engineer usually owns the service in production: its targets, its alerts, the response when it fails and the engineering that stops the same failure coming back. In small companies one person often does both. The job description tells you more than the title does.
Which one does your software need?
Most businesses that run their own software do not need an SRE team. A team of four engineers cannot staff a separate reliability function. What a small team can do is borrow the habits that cost little and prevent the most damage:
- Write one or two targets from the user’s side. Pick the request that matters most, such as checkout, sign-in or the main report, and set a target for how often it should succeed and how fast. Start below 100%, as the SRE book advises.
- Agree in advance what happens when the target is missed. A one-paragraph rule (“reliability fixes go before features until we are back on target”) does most of what a full error budget policy does.
- Watch the four signals on each user-facing service: latency, traffic, errors and saturation.
- Cut every alert that does not need a person to act. If an alert fires every night and nobody does anything, delete it or fix what causes it.
- Write a blameless note after every serious incident. Cause, fix, and what will stop it happening again. Google’s triggers above are a good starting list.
- Count the repeated manual work. Anything someone does by hand every week is a candidate for automation, which is the same idea as the toil cap at a smaller scale.
From DevOps, the habits that pay back first are small releases through an automated pipeline, tests that run on every change, environments created from code, and DORA’s metrics read every month or so to see where work gets stuck.
Objectives, agreements and your support contract
The SRE book separates objectives from agreements. A service level agreement is a contract with users that includes consequences if it is missed, and the book’s test is simple: if there is no explicit consequence, it is almost certainly an objective, not an agreement. That distinction is useful when you read a support contract. The internal targets your engineers work to can be stricter than anything promised in the contract, and they should be, so that a miss shows up internally before it reaches the contract.
When another company maintains your software, ask which of the habits above it follows. Who receives the alerts? What counts as a top-severity issue, and what are the response and resolution targets for each level? What do you receive in writing after a serious incident? A provider that can answer those questions plainly is already working in the way both DevOps and SRE describe, whatever it calls itself.
How we look after software in production
This is how our maintenance and support retainers are run. We monitor errors, availability and performance, and the alerts reach the same engineers who work on your system under the retainer. Every contract sets a response target and a resolution target for each severity level; we agree them per contract and do not publish a standard figure. After any incident at the top severity level, you get a brief note in writing that explains what caused it and what we changed. Backups run on your own infrastructure, we check that they complete, and a restore is tested on a schedule.
We charge one fixed fee each month, for a scope written down once we have reviewed the system. Code written by another team gets a short paid audit before any retainer is quoted, and you keep the audit’s findings whoever maintains the code afterwards. To start, tell us what the system does and which other systems it talks to; we answer inside one business day.
The full service behind this post: Software Maintenance Services & Support.
Ready to scope your project?
Send us two sentences about what you need. We reply within one business day with the next step and any questions we need answered first.