The most reliable way to implement site reliability engineering (SRE) is to start small. Pick one business-critical service, define what “working” means for its users, turn that into a service level objective (SLO), and let the error budget steer decisions about releases and risk. Once one team has done it and learned from it, you scale the practice. Rolling it out across the whole organisation at once is where most programmes stall.
This guide is written for ntegration managers who need a sequence they can fund, staff and measure. It covers the roadmap, the numbers behind SLOs, the practices that matter most, the tooling, and how to judge your maturity. It also covers what changes when the estate is a tangle of integrations, legacy platforms and AI components.
Key Takeaways
- Start with one important, actively developed service and one empowered team, then scale through champions and repeatable training.
- SLOs built on critical user journeys give executives and engineers a shared language for reliability, and the error budget turns that language into release decisions.
- Observability (traces, metrics and logs) and automation are what make an SRE practice sustainable, but they follow the SLOs, not the other way round.
- Treat maturity models as a reflective tool, not a league table, or teams will optimise the score instead of the service.
- In integration-heavy and AI-enabled estates, reliability depends on the connections between systems, so those need SLOs too.
Table of Contents
- What SRE is, and how it differs from DevOps
- A step-by-step roadmap for implementing SRE
- Making SLOs and error budgets concrete
- SRE best practices that earn their keep
- Observability and automation: the tooling layer
- SRE in integration-heavy and AI-enabled estates
- Assessing your SRE maturity
- Perspective: reliability is designed, not inspected
- Putting SRE into practice with Polarising
- FAQ
- Sources
What SRE is, and how it differs from DevOps
SRE applies software engineering to operations problems. Instead of scaling operations by adding people to look after more machines, you write automation and design services so they can be operated sustainably at scale.
People often ask whether SRE replaces DevOps. It does not. Google describes DevOps as a broad culture and set of practices for collaboration and delivery, while SRE is a role, a set of practices and a set of beliefs that implements part of that philosophy through concrete work on service reliability (Google SRE Workbook). In practice, DevOps tells you that development and operations should work together. SRE gives you specific mechanisms for doing it: SLOs, error budgets, bounded toil, blameless postmortems.
For a board or executive team, the useful framing is this: SRE makes reliability a measurable product attribute with an owner, a target and a budget, rather than a vague aspiration that only surfaces after an outage.
A step-by-step roadmap for implementing SRE
The sequence below follows the approach Google Cloud sets out for jumpstarting a practice, adapted for enterprise reality.
Step 1: Choose the first service carefully
Google Cloud advises starting with a business-critical application that is under active development and produces behavioural data you can measure (Google Cloud Blog). Each of those three attributes matters:
- Business-critical, so leadership cares about the result and will back the changes it suggests.
- Actively developed, so the findings can actually change how the service is built and released.
- Measurable, so you can define indicators from real user behaviour rather than guesses.
Resist the temptation to begin with the most troubled legacy system. Prove the model on a service where you can win, then take it into harder territory.
Step 2: Staff it lightly but deliberately
You do not need a new department. Google Cloud recommends allocating engineering time and identifying at least one part-time SRE advocate, which lets you test practices and adapt them before making structural changes (Google Cloud Blog). The same guidance from Google Cloud favours a proof of concept, learning from mistakes and iterating over an immediate organisation-wide transformation (Google Cloud Blog).
The executive decision here is simple: ring-fence time. If the advocate’s SRE work is squeezed out by feature delivery, the pilot will quietly die.
Step 3: Map critical user journeys
List the journeys users take through the service and rank them by business impact. For a payments platform that might be “submit a payment” and “see confirmation”. For a logistics business it might be “book a collection” and “track a parcel”. These journeys, not servers or clusters, are what you measure.
Step 4: Define SLIs and set SLOs
A service level indicator (SLI) is a measurement of something users experience, such as the proportion of requests that succeed or complete within a set time. An SLO is the target for that indicator over a defined period. Google Cloud’s practical guidance is to select SLIs that accurately track user experience, set targets and measurement periods, build consoles for the SLIs, SLOs and error budget, and set burn-rate alerts (Google Cloud Blog).
Keep the first set small: two or three SLIs per journey at most. A short list that people read beats a long one that nobody trusts.
Step 5: Agree the error budget policy
The error budget is the amount of unreliability your SLO permits. It is only useful if there is a written policy for what happens when it runs low. Google’s production practices describe balancing reliability and innovation with error budgets, and freezing changes when the budget is spent, with exceptions for urgent security and bug fixes (Google SRE Book).
This is the step that needs a senior sponsor. A budget that engineering can ignore is a dashboard, not a policy. Agree in advance, with product and operations leadership, what a freeze means and who can lift it.
Step 6: Review, then scale
Review your SLOs every six to twelve months, since user expectations and architecture both drift (Google Cloud Blog). Once the first team has a stable rhythm, spread the practice through communities, champions, repeatable training and formal processes, as Google Cloud suggests (Google Cloud Blog). Each new team should inherit templates, not start from a blank page.
Making SLOs and error budgets concrete
SLO conversations often stay abstract until someone does the arithmetic. Google Cloud defines the error budget as (1 minus the SLO goal) multiplied by the eligible events in the compliance period. For an 85% SLO over 60,480 requests, the permitted number of bad events is 9,072 (Google Cloud Observability documentation).
Time-based targets are easier to picture. A 99.99% availability SLO over a rolling 30-day period leaves a 0.01% budget, which is just over four minutes of downtime (Google Cloud service mesh documentation).
| Question to ask | Why it matters to leadership |
|---|---|
| Which user journey does this SLO protect? | Ties reliability spend to revenue or customer outcomes |
| What happens when the budget is nearly spent? | Makes the trade-off between features and stability explicit |
| Who owns the SLO? | Gives reliability a named accountable owner |
| When do we next review the target? | Prevents stale targets from driving decisions |
A higher target is not automatically better. Each extra nine costs more to deliver and shrinks the room for change. Set the SLO at the level where users would genuinely notice a drop, not at the level that sounds impressive.
On alerting, Google Cloud recommends burn-rate alerts, for example paging when a service is consuming its error budget at twice the baseline rate (Google Cloud Blog). Burn-rate alerts warn you about trends that threaten the objective, instead of paging for every blip.
SRE best practices that earn their keep
The search for “best practices” can produce long, undifferentiated lists. These are the ones with the strongest backing and the clearest effect on enterprise outcomes.
Roll out changes progressively. Google’s SRE guidance recommends supervised, progressive rollouts in which a change reaches a small fraction of capacity or traffic at a time, potentially across different geographies, and advises rolling back before diagnosing when behaviour is unexpected (Google SRE Book). The cultural shift is to treat rollback as the first response, not an admission of failure.
Bound operational work. Toil is manual, repetitive work that scales with the service and adds no lasting value. Set a ceiling on it and use the remaining time for automation and design improvements. The same guidance covers practising incident response and holding blameless postmortems (Google SRE Book).
Make on-call sustainable. Google’s team lifecycle handbook treats sustainable on-call, toil limits, postmortem learning and stakeholder reporting as organisational capabilities rather than tooling features (Google SRE Workbook). That has a budget consequence: you cannot buy your way to it with a monitoring licence.
Protect psychological safety. Blameless postmortems only work if people feel safe describing what happened. We have written about why this matters in agile teams in our piece on psychological safety in Scrum teams, and the same principle applies to incident reviews.
Report reliability to stakeholders on a rhythm. A monthly view of SLO attainment, budget consumption and the actions taken gives executives visibility without requiring them to read incident tickets.

Observability and automation: the tooling layer
Tooling comes after the SLOs, because you need to know what you are measuring. When you do choose it, the principles matter more than the brand names.
Observability
OpenTelemetry defines observability as the ability to understand a system from the outside and investigate problems you did not anticipate. Properly instrumented applications emit traces, metrics and logs, and distributed tracing is especially important in complex distributed systems (OpenTelemetry). In an integration estate, where one customer request may cross a gateway, a message broker and several back-end systems, traces are often the only way to see where time or errors accumulate.

At enterprise scale, OpenTelemetry’s guidance on managed telemetry platforms recommends centrally managed platforms, consistent SDK and instrumentation configuration, shared semantic conventions and Collector architectures, with self-serve tooling to reduce configuration sprawl, cognitive load and single points of failure. It also advises monitoring the Collector’s own telemetry and alerting on resource exhaustion and failed receiving or exporting before data is dropped (OpenTelemetry). In plain terms: monitor your monitoring, or you will find the gap during an incident.
Automation
Automation is how SRE removes toil. Provisioning, configuration, deployment and rollback should all be repeatable and scripted. If you want a view of the infrastructure side of this, the topic of automating server provisioning shows how scripted setup compares with instant, ready-made servers.
Automate in this order: the tasks that wake people at night, the tasks that happen most often, then the tasks where manual error is most costly. Keep a short log of toil removed, since it is the clearest evidence of the practice paying back.
SRE in integration-heavy and AI-enabled estates
Most enterprises do not run one tidy application. They run dozens of systems connected by APIs, events and file transfers, some of them decades old. Reliability in that environment is largely a property of the connections.
Three adjustments help:
- Put SLOs on the integration layer. If an order, claim or booking depends on a message passing through an integration platform, the success rate and latency of that hop is part of the user journey. Measure it as such.
- Standardise telemetry across platforms. Traces that break at every platform boundary are of little use. Agree on common correlation identifiers and instrumentation conventions across your APIs, event brokers and iPaaS flows.
- Plan for legacy. Systems that cannot emit modern telemetry still need an indicator. A synthetic transaction or a wrapper at the integration point often provides it until the system is modernised.
This is where our own experience sits. We engineer integrations on Boomi, MuleSoft, TIBCO and Solace, and we treat observability, error handling and governance as part of the design from the first sprint rather than something added once the interfaces are live. Whichever platform an enterprise has standardised on, the SRE questions are the same: what does the user journey need, where can it fail, and how will we know first.
AI components add further failure modes. Google Cloud’s reliability guidance for AI and ML systems recommends scalable, highly available infrastructure, holistic observability, and proactive monitoring of latency, throughput and model and data drift, with SLOs, error budgets and burn-rate alerts applied as for other services (Google Cloud Architecture Framework). A model that returns answers quickly but has quietly drifted is a reliability problem even though every server is green.
For organisations that want a formal anchor, IEEE 2675-2021 specifies system reliability engineering requirements across development, operations, management and governance within the DevOps process, with automation intended to identify issues affecting end users and support continuous operations (IEEE Standards Association). It is a useful reference when governance teams ask what “good” looks like.
Assessing your SRE maturity
A maturity model helps you decide what to do next. It should not become a scorecard for the board.
The USENIX reliability maturity model assesses reliability across operational processes, risk management, productivity, system complexity, people, leadership, and visibility and culture. It describes absent, reactive, proactive, strategic and visionary stages, and says they should stay fluid and be assessed introspectively, because turning them into a gamified checklist encourages behaviour that chases the score (USENIX).
Google’s team lifecycle handbook gives a concrete picture of the mature end. Its characteristics include SLOs with an exercised error budget policy, sustainable and compensated on-call, documentation and training, bounded toil, established postmortems, disaster recovery exercises and regular stakeholder reporting (Google SRE Workbook).
A simple self-assessment you can run in a workshop:
| Stage | What it looks like in practice |
|---|---|
| Reactive | Incidents drive the agenda; no agreed SLOs; postmortems are rare or blame-focused |
| Proactive | SLOs exist for key services; on-call is organised; toil is tracked |
| Strategic | Error budgets influence release decisions; reliability is reported to leadership regularly |
| Visionary | Reliability is designed in from the start and shared across teams as a platform capability |
Run the assessment per service or per team, not once for the whole company. Maturity is rarely uniform, and the gaps between teams tell you where to invest.
Perspective: reliability is designed, not inspected
We have spent over 20 years engineering enterprise systems, and one pattern repeats: reliability problems are rarely about a single failed server. They sit in the seams, in the integrations between platforms, the legacy systems nobody wants to touch and the handoffs between teams.
That is why we argue for starting SRE where the business feels it most, and for putting the integration layer inside the scope from day one. An SLO on a customer journey that ignores the message broker or API gateway in the middle is only half a measurement.
It is also why we build with senior engineers. Defining a sensible SLI, deciding what a rollback looks like for a regulated workload, and designing governance and accountability into an AI system from the outset all call for experience. Our nearshore teams in the UK and Portugal are set up to bring that seniority to complex, legacy-heavy estates, and to scale the team up or down as the practice matures.
Our advice to leaders: fund one pilot properly, give it a sponsor, write the error budget policy before you need it, and let the evidence from that pilot persuade the rest of the organisation.
Polarising Team
Putting SRE into practice with Polarising
If your reliability challenges sit in complex integrations, legacy platforms or AI-enabled applications, we can help you design and build with SRE principles from the start. Our enterprise integration services cover API and event platform integration, and our AI engineering services take AI from pilot to production with governance built in.

Talk to us about a focused first engagement through Polarising, and we will help you choose the right service for the pilot, define its SLOs and build the foundations to scale.
FAQ
How long does it take to implement SRE?
A first pilot on one service can be running in a matter of months, since it needs a defined set of user journeys, a small number of SLOs and an agreed error budget policy. Scaling across an enterprise is a longer, iterative effort. Google Cloud recommends proving the approach on a proof of concept and iterating rather than attempting a full transformation at once (Google Cloud Blog).
Do we need a dedicated SRE team?
Not at the start. Google Cloud suggests allocating engineering time and naming at least one part-time SRE advocate, so you can test practices before restructuring (Google Cloud Blog). A dedicated team makes sense once several services share the same needs and the pilot has shown results.
What is the difference between an SLI, an SLO and an error budget?
An SLI measures an aspect of user experience, such as the share of successful requests. An SLO is the target for that measure over a period. The error budget is the amount of failure the SLO allows, calculated as one minus the SLO goal, multiplied by the eligible events (Google Cloud Observability documentation).
How often should we revisit our SLOs?
Google Cloud recommends reviewing them every six to twelve months (Google Cloud Blog). Review sooner after a major architecture change, a migration or a shift in what customers expect.
Sources
- Google SRE Workbook: How SRE relates to DevOps
- Google Cloud Blog: Four steps to jumpstarting your SRE practice
- Google Cloud Blog: How SRE teams are organized and how to get started
- Google Cloud Blog: Learn how to set SLOs
- Google Cloud Observability: Concepts in service monitoring
- Google Cloud service mesh: Designing SLOs
- Google SRE Book: Production Services Best Practices
- Google SRE Workbook: Team lifecycles
- OpenTelemetry: Observability primer
- OpenTelemetry: Managed telemetry platforms for Kubernetes workloads
- USENIX: Reliability maturity model
- Google Cloud Architecture Framework: AI and ML reliability
- IEEE SA: IEEE 2675-2021
Recommended
- Site Reliability Engineering for Practitioners: SLOs and Careers
- BSS OSS Integration: An Architecture Guide for Telecom Leaders
- Enterprise Strangler Pattern: Pilot New Traffic, Keep Legacy Live
- Vector Database Integration: An Enterprise Architecture Guide
Content strategy and optimisation for Google and AI-powered search platforms by Velveteen SaaS — specialists in online visibility and customer acquisition.
