Senior Site Reliability Engineer

About the role

Our Azure SaaS estate keeps service management running for thousands of organisations worldwide, with SLA-backed 24/7 availability. As a Senior Site Reliability Engineer, you own the reliability of that estate as an engineering problem — you set the SLOs, engineer out the toil behind them, and make the platform faster to change and cheaper to operate without trading away resilience.

You sit in the SaaS infrastructure function, working alongside cloud engineering and the product squads shipping to production. You bring our AI-native ways of working into reliability: agents and bounded automation with observability, approvals, containment, and rollback — self-healing systems, not runbooks worked by hand.

What this is not

This is not a ticket-driven, break-fix ops role kept away from the code. This is reliability as engineering — you own SLOs and error budgets, automate what you repeat, and design the platform to recover itself rather than reacting incident by incident.

The team

We are a group of social technicians who value transparency, open feedback, and a healthy work-life balance — and who treat reliability as a shared, measurable objective, not a firefight.

What you’ll own

• SLOs and error budgets. Define and own service-level objectives across the Azure (and potentially multi-cloud) estate, and use error budgets to steer the balance between shipping change and protecting reliability.
• Toil elimination and self-healing automation. Identify toil, classify it, and engineer it out — feeding self-healing automation and your findings into the reliability roadmap. Stand up an agent-based support layer that owns recurring toil and continuously feeds improvements back into reliability.
• Observability consolidation. Standardise metrics, alerting, and tracing across all datacenters, close coverage gaps on cloud workloads, and measurably reduce the alert-to-incident ratio from baseline.
• Incident response and blameless postmortems. Lead incidents to resolution, run blameless postmortems, and turn every learning into a durable fix or an automation candidate.
• Reliability of releases. Harden CI/CD and progressive delivery — canaries, safe rollouts, automated rollback — so change velocity and reliability rise together.
• Capacity and performance. Model capacity, load-test critical paths, and keep the platform within its performance envelope as it scales across regions.
• AI-native reliability. Bring agents and bounded automation — with observability, approvals, containment, and rollback — into detection, diagnosis, and remediation.
• Runbooks that get used. Every alert links to a runbook; every runbook links to an automation candidate. You leave things more legible than you found them.
• Capacity and cost forecasting. Own capacity and cost planning across the multi-cloud estate, model usage and growth trends, and forecast short- and long-term infrastructure needs so spend and scaling decisions stay ahead of demand rather than reacting to it.

How you approach the work

• Automate what you repeat — if you have done it manually twice, the third time is a design problem.
• Measure before optimising: SLOs, baselines, and dashboards before opinions.
• Design for failure — assume things break, and make recovery automatic and observable.
• Consultative, not gatekeeping: you pair with product engineering teams and transfer knowledge as you go.
• Treat cost and reliability as joint objectives, not a forced trade-off.
• Work proactively with product teams and get involved early in product development, including design, to help teams make optimal choices and introduce the right SRE practices on time.

Technical environment

• Scale: 10+ global datacenters; SLA-backed, 24/7 multi-tenant SaaS serving millions of end users.
• Cloud: Azure across all production regions, with a mature landing-zone and networking architecture.
• Compute: Kubernetes / Azure AKS alongside traditional VM infrastructure, all managed as code.
• Infrastructure as code: Terraform via CI/CD and GitOps workflows; configuration management with Puppet and Ansible across Linux and Windows.
• Observability: metrics, alerting, and tracing across cloud-native and self-managed layers (e.g. Grafana, Prometheus, VictoriaMetrics, Influx).
• Automation: Python and automation tooling — and we expect you to take the reliability stack to the next level, not just operate today’s.
• Legacy: Java, MS SQL, heritage architecture — being decomposed. The SRE role is not responsible for the Java application code.
• How we build: Claude Code as our primary AI-native SDLC tool; subagents and multi-agent workflows; MCP tool integrations; shared prompt, agent, and eval libraries.

Success in your first year

• SLOs and error budgets are defined for the estate’s critical services and actively used to steer delivery decisions.
• The alert-to-incident ratio is measurably down, and runbooks you wrote are used by the on-call shift without escalation.
• Toil you identified is automated — or has a credible, documented roadmap to be — and self-healing covers at least one high-frequency failure mode.
• Postmortems produce durable fixes, not repeat incidents; recurring-incident rate is trending down against a documented baseline.
• Product squads consult you during design, not only after incidents.