SRE & DevOps practice certifications

Every other certification page on this site is about a thing — a cluster, a cloud, a secrets manager. This one is about a vocabulary. SRE Foundation, SRE Practitioner, DevOps Foundation and their DASA cousins teach you to say “error budget,” “toil,” “blameless postmortem,” “incident commander” and “value stream” and mean exactly the same thing as the person across the table. That is genuinely valuable: it is how platform teams negotiate with product managers, and it is what enterprise procurement counts. It is also a multiple-choice exam about ideas — it will not teach you to fix a broken cluster at 3 a.m. This page is about holding both truths at once.

What these credentials are and who issues them

☺ Like you’re 10: A company called DevOps Institute sells short multiple-choice exams about how teams should work. It got bought by a bigger exam company, so the badge now has two names on it.

The best-known family here is DevOps Institute: a set of short, knowledge-based certifications with names like DevOps Foundation, Site Reliability Engineering (SRE) Foundation and SRE Practitioner. They are taught by accredited training partners over one to three days, and assessed by a web-based multiple-choice exam. There is no lab, no cluster and no kubectl.

The branding really has changed — here is the current picture

Expect some confusion here, because there is some. In 2023 PeopleCert — the exam body that already owned AXELOS and ITIL — acquired DevOps Institute. The name and website survive, but every page now says “DevOps Institute is member of PeopleCert Group,” exams are sat on PeopleCert’s platform, and renewal follows PeopleCert’s CPD programme instead of the old one — devopsinstitute.com’s own “continuing education” page now redirects straight to PeopleCert. The honest answer to “who issues it?” is DevOps Institute branding, PeopleCert machinery — buy through either site and you reach the same checkout.

Two wrinkles before you trust a course brochure. The certification list on devopsinstitute.com and the one on peoplecert.org are not identical — devopsinstitute.com still shows DevOps Engineering Foundation and Certified Agile Service Manager in its index, but both of those tiles are dead ends — the URLs still resolve, yet they 301 straight to the DevOps Institute homepage rather than serving a certification page — and neither appears on PeopleCert at all. They are retired, not merely mislisted; treat the PeopleCert catalogue as the one that reflects what you can actually book. And the SRE exams publish no exam code: DevOps Foundation is branded DOFD, but SRE Foundation and SRE Practitioner carry only a service mark. Reseller alphabet soup like DOICSREFD or SREFND-LO-Ex is a training-partner course code, not an exam code.

The current portfolio, and what quietly disappeared

Now the part nobody advertises. Several certifications that DevOps Institute promoted heavily a few years ago are gone — Continuous Delivery Ecosystem Foundation (CDEF), Continuous Delivery Architect (CDA) and DevOps Test Engineering (DTE). We checked their old certification URLs while researching this page and none of them serves a certification page any more; they 301 to the devopsinstitute.com homepage.

Two more have since joined them, and these ones are worth naming carefully because they were on this very page as live options until recently: DevOps Engineering Foundation and Certified Agile Service Manager (CASM) have been retired. The published wind-down was 1 August 2025 as the last day to buy a voucher and 1 February 2026 as the last day to sit the exam, including Take2 re-sits. Both dates are now behind us, and both old certification URLs now 301 to the devopsinstitute.com homepage rather than serving a page, while neither certification appears in PeopleCert’s catalogue at all — which is why they are the one entry in the table above with no link on it. Plenty of third-party training sites still sell all five. Don’t buy a credential that its own issuer no longer lists.

The adjacent family: DASA

The other vendor-neutral practice body worth knowing is DASA (DevOps Agile Skills Association) — same shape, broader and more actively refreshed catalogue. Per the official DASA certification programs page as of writing: DASA DevOps Fundamentals as the entry point (€465), then a tier listed at €585 each that includes DASA Platform Engineering, DASA SRE Next Gen, Intelligent Continuous Security, Experience Management, Product Management, Portfolio Management, DevOps Specify and Verify and DevOps Enable and Scale, plus DevOps Product Owner (€818) at leadership level. A few — DevAIOps, Transformational Leader, DevOps Coach — are listed without a public price, so ask before you assume €585. DASA Platform Engineering leans hard on developer experience, which is our Developer Experience lesson.

Why you might take one — and when to skip it

☺ Like you’re 10: Great if the problem is “our team argues about words and nobody agrees when to stop shipping.” Useless if the problem is “nobody here can debug the cluster.”

Take one if…

You are about to introduce SLOs and error budgets and expect a fight. The strongest case by far. Error budgets are a political instrument disguised as arithmetic — they decide when a team stops shipping features. Our Reliability & Incidents lesson gives you that content free; the certification gives you the thing a lesson cannot, which is everyone in the room having read the same thing.

Procurement or a framework demands it. Vendor questionnaires, managed-service bids and some public-sector tenders count certified staff, and ITIL-shaped organisations recognise PeopleCert paperwork instantly. Not an intellectual argument, but a real one — and usually paid for by someone other than you.

You are moving from engineer to lead. Toil budgets, incident command, on-call ergonomics and blameless postmortems are an SRE lead’s actual week, and hands-on exams barely touch them. Pair it with Team Topologies and Best Practices.

Skip it if…

You cannot yet debug a failing workload. Blunt version: a multiple-choice exam about reliability held by someone who cannot read a pod’s events is a costume. Do CNPA, then CNPE, then CKA if you lack it — see the certifications hub.

You have already read the Google SRE books. This is the most important honesty on the page, and the evidence is inside the vendor’s own materials: DevOps Institute’s official SRE Practitioner study guide is, to a striking degree, a curated reading list of free resources — Google’s SRE Book and Workbook, PagerDuty’s incident-response documentation (free, open, on GitHub) and Principles of Chaos Engineering. If you have worked through those, the exam mostly tests whether you remember them.

Your budget is one certification this year and you are paying. Then it is a hands-on one. Every time.

You want a badge that survives a recruiter screen. Adverts ask for CKA, CKAD, CKS and increasingly the CNCF platform credentials; SRE Foundation appears far less often, and almost never as a hard requirement outside consultancies and large enterprises.

What the exams actually test

☺ Like you’re 10: Forty multiple-choice questions about ideas from a two-or-three-day course. Open book. No cluster.

A caveat we are going to be strict about: the vendor does not publish percentage weights per domain for the SRE exams the way CNCF publishes a blueprint. It publishes an objective list, and the exam is drawn from the course. Third-party sites circulate per-domain question counts; we read the vendor’s own study-guide PDF and it defines scope and supplies a reading list rather than a weighted blueprint, so those counts are not on this page. The tables below are transcribed from the official certification pages and the official SRE Practitioner exam study guide.

SRE Foundation — the published objectives

SRE Practitioner — the eight modules

The Practitioner level is the interesting one for readers of this site, because module 5 says the quiet part out loud. Transcribed from the official DevOps Institute SRE Practitioner Exam Study Guide (v1.0, July 2021 — the most recent version we could find published by the vendor):

Note what module 5 implies: the SRE certification body’s own answer to “how do you scale reliability practice?” is build a platform. That is the thesis of this entire site, arriving from the other direction.

One caveat on that table. The published study guide is dated 2021, while the current certification page describes the course in newer language — zero-trust security, distributed tracing, AI-driven incident management, DataOps and data lineage, and SRE execution models. Those map onto the same eight modules rather than replacing them, but the course has clearly been refreshed since the guide was written, so treat the module titles as the shape of the exam rather than a word-for-word blueprint, and check the official page before you buy.

The substance you actually need to know

☺ Like you’re 10: Three ideas do most of the work — a budget for being broken, a name for boring work, and one person in charge during a fire.

An error budget is arithmetic, not a mood

The exams ask you to reason about budgets in words. Here is what those words mean in a real cluster. A 99.9% availability SLO over 30 days permits about 43 minutes of badness. The professional move is not one “are we down?” alert but a multi-window, multi-burn-rate alert: page loudly when the month’s budget is burning fast, ticket quietly when it burns slowly.

groups:
  - name: checkout-slo
    rules:
      # SLI: fraction of requests that FAILED, precomputed at several windows
      - record: job:slo_error_ratio:rate5m
        expr: |
          sum(rate(http_requests_total{job="checkout",code=~"5.."}[5m]))
            / sum(rate(http_requests_total{job="checkout"}[5m]))
      - record: job:slo_error_ratio:rate1h
        expr: |
          sum(rate(http_requests_total{job="checkout",code=~"5.."}[1h]))
            / sum(rate(http_requests_total{job="checkout"}[1h]))
      - record: job:slo_error_ratio:rate30m
        expr: |
          sum(rate(http_requests_total{job="checkout",code=~"5.."}[30m]))
            / sum(rate(http_requests_total{job="checkout"}[30m]))
      - record: job:slo_error_ratio:rate6h
        expr: |
          sum(rate(http_requests_total{job="checkout",code=~"5.."}[6h]))
            / sum(rate(http_requests_total{job="checkout"}[6h]))

      # SLO = 99.9%  ->  budget = 0.001 of requests over 30 days.
      # Burn rate 14.4x exhausts the whole month's budget in ~2 days: page a human.
      - alert: CheckoutErrorBudgetBurningFast
        expr: |
          job:slo_error_ratio:rate5m > (14.4 * 0.001)
            and job:slo_error_ratio:rate1h > (14.4 * 0.001)
        for: 2m
        labels: { severity: page }
        annotations:
          summary: "Checkout is burning its 30d error budget ~14x too fast"
          runbook: "https://runbooks.acme.io/checkout/slo-burn"

      # Slow burn: real, but it can wait for office hours. 6x over a 6h window
      # burns the month's budget in ~5 days. Same two-window trick, longer
      # windows. This is the alert that stops SLOs becoming pager fatigue.
      - alert: CheckoutErrorBudgetBurningSlow
        expr: |
          job:slo_error_ratio:rate6h > (6 * 0.001)
            and job:slo_error_ratio:rate30m > (6 * 0.001)
        for: 15m
        labels: { severity: ticket }

Two exam-flavoured points hide in that YAML. The and across two windows stops a thirty-second blip paging anyone — that is the “multi-window” idea. And the split between page and ticket is the practical meaning of “error budget policy”: the budget does not just measure, it routes. Build it on Prometheus, watch it in Grafana.

Toil is a number you can put on a slide

“Reducing Toil” is objective 3, and the definition the exams want is precise: work that is manual, repetitive, automatable, tactical, devoid of enduring value, and that scales linearly with service size. The useful discipline is counting it before you argue about it.

# 1. Who is interrupting the platform team right now?
#    Toil budget target from the SRE literature: keep it under 50%.
#    NOTE: /api/v2/alerts returns alerts that are ACTIVE at this moment --
#    it is a snapshot, not history. For a month's worth, query Prometheus
#    (step 4) or export from your paging tool.
curl -sG http://alertmanager:9093/api/v2/alerts \
  --data-urlencode 'filter=severity="page"' \
  | jq -r '.[].labels.service' | sort | uniq -c | sort -rn

# 2. Which of those pages are automatable? A page that fires more than
#    a handful of times a month with the SAME runbook is not an incident --
#    it is a missing controller. That is the SRE-to-platform pivot.

# 3. The reliability half of the DORA four: change failure rate.
kubectl argo rollouts list rollouts -A          # progressive delivery, see Argo Rollouts
kubectl get events -A --field-selector reason=RolloutAborted \
  -o custom-columns=NS:.involvedObject.namespace,NAME:.involvedObject.name,TIME:.lastTimestamp

# 4. How long was somebody paged, per service, over 30 days? The ALERTS
#    series only exists while an alert is pending or firing, so counting its
#    samples and multiplying by the rule evaluation interval gives duration.
#    (Do NOT use ALERTS_FOR_STATE for this -- its VALUE is the unix timestamp
#    the alert became active, not a duration.)
#    sum by (service) (
#      count_over_time(ALERTS{alertstate="firing",severity="page"}[30d])
#    )  # x evaluation_interval, in minutes -- the number an exec understands

Step 2 is where a reliability practice becomes a platform. A recurring page with a fixed runbook is a controller you have not written yet — see Platform APIs & CRDs, and the automatic-rollback machinery in Argo Rollouts and Flagger.

Incident command is a role, not a rank

Module 6 is the part most engineers were never taught. The model the exams reflect — and which PagerDuty publishes free — separates the Incident Commander (decides, delegates, owns it; does not debug), the Deputy, the Scribe (timestamps everything), Subject Matter Experts (the only people touching keyboards) and a Customer Liaison. The commander can be the most junior person in the channel, because commanding is a different skill from fixing. Then a blameless postmortem that hunts the system which permitted the mistake, not the human who made it — same structure as our Reliability & Incidents and Delivery triage pages.

How this maps onto the CNPE and onto this site

☺ Like you’re 10: This family teaches the words and the rules. The CNPE checks you can actually build and fix the thing. Barely any overlap — which is exactly why they go together.

Read that last row twice. It is the entire argument of this page compressed into one line.

Exam logistics, as published

☺ Like you’re 10: Forty questions, an hour or ninety minutes, open book, about two hundred pounds, and it expires after three years.

Everything below is transcribed from the official DevOps Institute and PeopleCert pages linked at the end, re-verified July 2026. Prices are the figures PeopleCert lists in GBP for the exam-voucher option; your currency, tax and any training bundle will differ. Third-party “exam dump” sites quote a 70% pass mark for these exams — the official PeopleCert pages say 65%, and that is what we use here.

For contrast, the DASA equivalents as published on DASA’s own site: DASA DevOps Fundamentals — 40 multiple-choice questions, 60 minutes (plus 15 minutes for non-native speakers), closed book, live webcam proctoring, 65% to pass, 16 hours of course content, voucher valid 12 months, €465. DASA Platform Engineering — 40 questions, 80 minutes, closed book, webcam-proctored online, 65% to pass, 16 hours of course content, €585.

Verdict: where it fits in a realistic order

☺ Like you’re 10: Learn to fix things first. Learn the words second — and if you only ever do the free reading, that is completely fine.

Our honest recommendation for the reader of this site:

First, build hands-on capability. CNPA if you are early, then CNPE, with CKA in the mix if you lack it. Performance-based, screened on by employers, cheaper than the practice exams. Nothing here should displace them.

Second, do the free reading properly. Google’s SRE Book and Workbook and PagerDuty’s incident response documentation are free, excellent, and exactly what the vendor’s own study guide points at. Add Reliability & Incidents, Observability, Team Topologies and Best Practices here, then do Ellie’s exercise for real.

Third — and only then — consider SRE Foundation, ideally on a training budget and with two or three colleagues, so the vocabulary takes root in your team rather than in your LinkedIn profile. Take SRE Practitioner only if you are personally accountable for reliability across several services.

Consider DASA Platform Engineering instead if the label matters to your employer and you want the process framing pointed at platforms rather than reliability — compare it honestly against the Platform Engineering University ladder first.

Skip entirely if you are paying your own way and picking one credential this year. Buy the one with a cluster in it. You can read your way to the vocabulary; you cannot read your way to being the person who fixes production.

Official sources verified for this page: DevOps Institute certifications, SRE Foundation, SRE Practitioner, DevOps Foundation, the PeopleCert DevOps catalogue, PeopleCert’s acquisition announcement, and the DASA programs and DASA Platform Engineering pages. Compare with the CNCF ladder on our certifications hub and the mechanics in the CNPE exam guide.