Career path

Site Reliability Engineer

Make sure production services meet their reliability, availability and performance objectives, by measuring what users experience, automating repetitive work and turning every incident into a lasting improvement.

Aim for this jobWhat this job does

• 7 responsibilities
• 14 missions
• 44 skills
• 217 hours of work an estimate, starting from zero

Your gap

What you are missing

Aiming for this job computes your path from what you have already read and passed (quizzes, labs). You then see everything that remains from your first step.

297

lessons

~217 h

from zero

Aim for this job

Saved in this browser. Can be changed at any time.

The job

What a Site Reliability Engineer does

Seven responsibilities. Each one is carried out through concrete missions, which require skills.

1

Solve recurring problems at their root cause

Design and improve 1 mission · 2 skills

Missions that make it up

• Bring a broken server back

  Deliverablea repaired server whose services are restored and stay so after a reboot

  • Maintain a server's software and monitor its resources
  • Troubleshoot a Linux server

  2 skills Proof lab

2

Manage incidents

Do on your own 3 missions · 9 skills

Missions that make it up

• Run a postmortem and follow up its actions

  Deliverablea blameless postmortem, its causes and actions tracked to closure

  • Write a clear, accessible and verifiable technical page
  • Document operations: runbooks, checklists, decisions
  • Keep documentation alive: owner, review, freshness
  • Respond to an incident and write a postmortem

  4 skills No lab yet

• Hold on-call and document operations

  Deliverablean on-call rota and its escalation defined, every alert linked to its runbook, an incident handled through to recovery

  • Write a clear, accessible and verifiable technical page
  • Document operations: runbooks, checklists, decisions
  • Keep documentation alive: owner, review, freshness
  • Respond to an incident and write a postmortem
  • Run a sustainable on-call rotation

  5 skills No lab yet

• Bring an application back on a cluster

  Deliverablean application answering again, its faults found with no ticket and no procedure

  • Expose an application with a Service, Ingress or Gateway
  • Provide persistent storage to an application
  • Control where Pods are placed
  • Troubleshoot a failing application on Kubernetes

  4 skills Proof lab

3

Ensure continuity and resilience

Do on your own 2 missions · 4 skills

Missions that make it up

• Ensure a service's continuity and capacity

  Deliverablea recovery plan proven by a drill, recovery objectives (RTO, RPO) met and anticipated capacity

  • Plan a fleet's capacity
  • Ensure continuity: high availability, recovery, backups

  2 skills No lab yet

• Guarantee a service's availability on Kubernetes

  Deliverablea service that survives voluntary disruptions and the loss of a node, with no measured interruption

  • Ensure continuity: high availability, recovery, backups
  • Make a workload reliable: health probes and resources
  • Keep an application available during disruptions

  3 skills No lab yet

4

Reduce repetitive work through automation

Do on your own 2 missions · 8 skills

Missions that make it up

• Automate a repetitive operations task

  Deliverablea tested tool that replaces a manual step across a fleet, reading and producing structured data

  • Read and transform data (JSON, YAML, APIs)
  • Maintain a fleet: updates, drift, debt
  • Write a tested command-line tool
  • Automate a fleet's administration from Python: SSH, deployment and network scanning
  • Read, install and modify a small Python tool
  • Run pytest tests, read a failure and fix a simple defect

  6 skills No lab yet

• Ship an internal tool to other teams

  Deliverablean internal tool that is tested, reviewed, versioned and installable by other teams without help

  • Read, install and modify a small Python tool
  • Run pytest tests, read a failure and fix a simple defect
  • Review someone else's Python code and get your own checked
  • Make a Python tool installable and versioned

  4 skills Proof lab

5

Observe and measure the service delivered

Do on your own 2 missions · 7 skills

Missions that make it up

• Make a service observable

  Deliverablea service whose metrics and logs are collected, queryable and visualised, with actionable alerts on its symptoms

  • Query a service's metrics to answer an operations question
  • Centralize a service's logs and query them
  • Collect a service's metrics and check their quality
  • Build a dashboard that answers an operations question
  • Define an actionable alert and route it without noise

  5 skills No lab yet

• Define an SLO and alert on its error budget

  Deliverablea reliability objective measured on an indicator of the service delivered, an alert on the consumption of its error budget

  • Observe, respond to incidents, hold an SLO

  1 skill Proof lab

Also required, outside missions

• Observe a cluster's health and resource usage

6

Change and deploy without putting the service at risk

Do on your own 3 missions · 12 skills

Missions that make it up

• Describe infrastructure as shareable, replayable code

  Deliverablean infrastructure split into versioned modules, its state shared and locked, replayed identically

  • Predict what an IaC tool will create, change or destroy: declarative model, idempotence, state and plan
  • Keep an IaC repository healthy: layered structure, plan review, testing pyramid and secrets out of the code
  • Structure infrastructure as code at scale: stacks, versioned modules, environments and debt
  • Share a remote, locked and recoverable Terraform state
  • Consume and version Terraform modules reproducibly
  • Design, structure and test a reusable Terraform module

  6 skills Proof lab

• Deploy with GitOps

  Deliverablenotes-api deployed and promoted between two environments from Git

  • Deploy and observe an application on Kubernetes
  • Deploy an application with GitOps
  • Synchronize and promote across environments

  3 skills No lab yet

• Roll out a change progressively without service interruption

  Deliverablea new version deployed in stages, its availability held and its rollback ready

  • Update an application and roll back
  • Make a workload reliable: health probes and resources
  • Change Kubernetes resources declaratively without drifting from Git
  • Synchronize and promote across environments

  4 skills No lab yet

7

Guarantee service reliability and performance

Do on your own 1 mission · 5 skills

Missions that make it up

• Size a service and anticipate its load

  Deliverablea service whose resources, scaling and future capacity are measured and justified

  • Monitor processes and performance
  • Plan a fleet's capacity
  • Make a workload reliable: health probes and resources
  • Scale an application automatically
  • Match a cluster's node count to pending Pods and shrink it without disrupting the service

  5 skills No lab yet

The means

With which tools?

Choose your tools: the choice changes the lessons to read, never the responsibilities.

GitOps tool

Argo CD Flux

Automation language

Python Go

Going further

Specialisations

Optional, measured apart from the job.

Administer the runtime platform

• Install a Kubernetes cluster
• Make the control plane of a kubeadm cluster highly available
• Maintain and manage nodes without service interruption
• Troubleshoot the control plane and nodes
• Upgrade a kubeadm cluster by one minor version

Diagnose a service backed by a relational database

• Read a schema and query relational data with SQL
• Diagnose a slow SQL query with indexes and EXPLAIN

Build maintainable Python tools

• Manipulate lists, tuples, sets and slices in Python
• Design Python classes: encapsulation, inheritance, abc and mixins
• Run concurrent work and choose the right model
• Harden a Python test suite: Hypothesis, pytest fixtures, coverage and mutation
• Model and type data in Python with dataclasses, Enum and annotations
• Write idiomatic Python: decorators, generators, context managers and itertools
• Profile and optimize a Python program, up to a native extension

Work with an AI coding agent, under control

• Scope a task given to Claude Code and check its result with a plan, a diff and tests
• Confine Claude Code's execution: permissions, secrets and sandbox
• Automate and extend Claude Code with hooks, skills and plugins
• Connect an MCP server to Claude Code and delegate to isolated subagents
• Take back control of a drifting Claude Code session and troubleshoot its configuration
• Deliver a complete project driven by Claude Code, one vertical slice at a time
• Run Claude Code without an interactive session, in CI, with the right model and cost

What the site does not cover yet

Signal correlation and distributed tracing: taught as concepts (optional module of the Observability training), with no published hands-on content (Tempo distributed tracing and correlation labs still in draft), with no active skill. Instrumenting a service (traces emitted and checked) and tracing an LLM application's calls into Tempo are practised and recommended; correlating signals and following a distributed trace across services remain concepts.

Non-functional testing (SFIA NFTS): covered by sizing and scaling. Controlled fault injection is being prepared (draft ops.fault.inject); the mission "Test a service's reliability with an induced failure" will join the role once it is taught. Load testing is not taught yet.

Problem management (SFIA PBMG level 4): the responsibility is only carried today by repairing an incident; the level 4 gesture (incident trends, root cause, lasting fix) is being prepared (draft ops.problem.resolve).

Data analytics (SFIA DAAN): limited to reading service measurements, level 2.

Around this job

Compare with another job →

All the skills →

×

See in the glossary →