Platform Engineering Certified Practitioner & Professional

Almost every certification a platform engineer can buy is really about a tool — this cloud, that orchestrator, this pipeline runner. The Platform Engineering University ladder is the rare exception: a credential about platform engineering as a discipline. Platform as a Product. The minimum viable platform. Golden paths and the right level of abstraction. Getting your first pioneering team onboard, proving ROI, surviving the executive review. It is also cohort-based and expensive, issued by a community with commercial roots, and far less recognised by hiring managers than a CNCF badge. All of that is true at once, and this page is about deciding honestly whether it is worth your money.

What this credential is and who issues it

☺ Like you’re 10: It’s a paid evening course with a test at the end, run by the big platform-engineering community website — not by a cloud company and not by the CNCF.

The Platform Engineering Certified Practitioner and Platform Engineering Certified Professional are issued by Platform Engineering University, the training arm of the platformengineering.org community — the same community behind the Platform Engineering Slack, the global meetups and the PlatformCon conference. Per its own about page, that community was launched by Humanitec (a commercial Internal Developer Platform vendor) and in 2024 spun out into a separate team, “Platform Engineering Masters.” The same page claims a Slack of “25k+ platform engineers” and “2000+ certified Platform Engineers” — while the university front page simultaneously advertises “3,200+ certified engineers.” Both numbers are self-reported marketing and they do not agree with each other; treat them as such.

That origin story matters. The curriculum is vendor-neutral in content — you will not spend five weeks learning Humanitec’s product — but it is written by people whose commercial worldview is “buy a platform orchestrator.” The concepts (Platform as a Product, minimum viable platform, golden paths, cognitive load) are genuinely the industry’s shared vocabulary — the same vocabulary our What is platform engineering? page builds from — and this community did more than anyone to popularise them. Just read the ROI module with the scepticism you’d bring to any vendor’s ROI calculator.

Where it sits: four paid rungs on a free base

What began as a single certification is now a branching path. Per the official Platform Engineering University catalogue as re-checked for this page, there are four paid certifications — Practitioner, Professional, Leader and Architect — sitting on top of a growing shelf of roughly ten free, self-paced courses. Importantly, nothing in the catalogue is hard-gated: the vendor recommends an order, and describes Professional and Architect as being “for graduates of Practitioner,” but as of writing no course page states a required prior certification. Treat the ladder as guidance, not as enforced prerequisites.

Why you might take it — and when to skip it

☺ Like you’re 10: This one is great if your problem is “nobody uses the thing we built.” It’s a waste of money if your problem is “I can’t build the thing yet.”

Take it if…

You are the person who has to make a platform land, not just work. The hardest part of platform engineering is almost never the YAML — it is choosing what not to build, finding a pioneering team, and holding a straight face in front of a VP asking why three engineers spent two quarters on “internal tooling.” That is precisely this material, and very little else on the market teaches it in a structured way. If you are the first platform engineer at a company, or newly made Head of Platform, the frameworks are worth having.

Your employer pays and you want the cohort. A meaningful part of the value is the live sessions and the alumni network — a room full of people wrestling with adoption at other companies. That is worth something a video course is not, and it is essentially impossible to justify on your own credit card.

You want to align a whole team on shared language. The community recommends putting a whole team through the same level together, and that is where it shines: everybody leaves using “golden path,” “MVP” and “cognitive load” to mean the same thing. Our Platform as a Product and Team Topologies pages cover that vocabulary for free — but a shared five weeks lands differently from a shared reading list.

Skip it if…

You are early in your Kubernetes journey. This is the big one. If you cannot yet debug a failing pod, write a CRD or wire up GitOps, spend the money and the months on the CNPE or the CNPA instead. Product framing without implementation ability produces the exact failure mode our Anti-Patterns page names first: a beautifully positioned platform that doesn’t work.

You already read the books. Much of the syllabus overlaps Team Topologies, the DORA research, and the free content this same community publishes. If you have internalised those and already run discovery interviews with your developers, you are largely paying for the cohort and the badge, not new ideas.

You need the badge to get past a recruiter screen. Job adverts ask for CKA, CKAD, CKS and increasingly the CNCF platform credentials; they very rarely ask for this one. Recognition is growing but it is not close. If your goal is “get an interview,” the CNCF ladder on our certifications hub is a better use of the same money.

Your budget is one certification this year. Then it should almost certainly not be this one, unless your job is already 70% stakeholder management.

You are buying it because of the salary claims. Worth saying plainly: the course pages advertise that “60% report salary growth or promotion within 6 months after getting certified” and that salaries “run up to 42% higher.” Neither figure carries a published methodology, sample size or source on the page — they are self-reported vendor marketing, and “up to” is doing heavy lifting. There is also no refund after enrolment (you can only transfer your seat to a later cohort), so a $1,800 decision made on those numbers is not one you can undo. Buy it for the material and the cohort, or do not buy it.

What it actually tests

☺ Like you’re 10: The “test” is 50 multiple-choice questions about the eight lessons you just sat through. It’s not a lab where you build something.

Neither level publishes an “exam blueprint” with weighted domains the way CNCF exams do — the vendor does not publish domain weights or percentages, so do not trust any page (including this one) that gives you some. What it publishes instead is the module list, and since the exam is drawn from the course, the modules are the objectives. Each module ships with its own quiz; the final exam is multiple-choice.

Practitioner — the eight modules

Professional — the eight modules

The Professional level assumes the Practitioner material and pushes into delivery, measurement and production-readiness. The vendor re-titled this syllabus at some point after our first pass — the module names below are the ones on the official course page as re-checked for this page, and older write-ups (including earlier versions of this one) quote a different set of titles for substantially the same content:

Notice what is not in either of those two lists: no scheduler internals, no CNI, no etcd, no “fix this broken pod.” That is the deliberate boundary of these two rungs — and the exact reason they complement rather than replace the CNPE.

One caveat, and it is a real change in the offering: the newer Certified Architect rung is hands-on. Its published modules cover policy-as-code (Kyverno, OPA Gatekeeper territory), runtime security with Falco by name, developer-facing platform APIs, platform CLIs, Kubernetes operators, and a capstone — and its exam is proctored. If you want a hands-on credential from this vendor, that is the one, and it overlaps our Security & Policy and security lab material far more than the Practitioner does.

The substance you actually need to know

☺ Like you’re 10: Three ideas carry the whole course — build the smallest useful thing, make the good way the easy way, and prove people are using it.

The golden path is a template, not a wiki page

“Golden path” gets said far more often than it gets built. In practice it is an executable template producing a repo, a pipeline, a deployment and a dashboard in one action — guardrails baked in as validation rather than documented as etiquette. Here is one as a Backstage software template:

apiVersion: scaffolder.backstage.io/v1beta3
kind: Template
metadata:
  name: golden-path-http-service
  title: HTTP service (Go) — the paved road
  description: Repo, CI, Helm chart, Argo CD app and a dashboard, from one form.
spec:
  type: service
  owner: group:platform
  parameters:
    - title: Tell us about your service
      required: [name, team, tier]
      properties:
        name:
          type: string
          pattern: '^[a-z][a-z0-9-]{2,29}$'     # a guardrail, not a naming-convention wiki
        team:
          type: string
          ui:field: OwnerPicker                  # ownership is captured at creation, always
        tier:
          type: string
          enum: [bronze, silver, gold]           # tier drives SLO, budget and backup defaults
  steps:
    - id: scaffold
      action: fetch:template
      input:
        url: ./skeleton
        values:
          name: '${{ parameters.name }}'
          tier: '${{ parameters.tier }}'
    - id: publish
      action: publish:github
      input:
        repoUrl: 'github.com?owner=acme&repo=${{ parameters.name }}'
    - id: register
      action: catalog:register                   # it exists in the catalogue from minute one
      input:
        repoContentsUrl: '${{ steps.publish.output.repoContentsUrl }}'
        catalogInfoPath: /catalog-info.yaml

It all reduces to one test: is this genuinely the path of least resistance? If a developer can go around it faster, they will, and you have built a suggestion. See Self-Service and Developer Experience.

“Find the right abstraction” means designing an API for humans

Module 5 is the intellectual heart of the Practitioner course and the most technical thing on the syllabus. Getting the abstraction right means the developer states intent in words they own, and the platform supplies everything else — on this site, a Crossplane composite API or a custom resource:

apiVersion: apiextensions.crossplane.io/v1
kind: CompositeResourceDefinition
metadata:
  name: xpostgresqls.platform.acme.io
spec:
  group: platform.acme.io
  names: { kind: XPostgreSQL, plural: xpostgresqls }
  claimNames: { kind: PostgreSQL, plural: postgresqls }   # what developers actually create
  versions:
    - name: v1alpha1
      served: true
      referenceable: true
      schema:
        openAPIV3Schema:
          type: object
          properties:
            spec:
              type: object
              properties:
                size:                     # three words a developer understands...
                  type: string
                  enum: [small, medium, large]
                retentionDays:
                  type: integer
                  default: 7
              required: [size]
---
# ...and the whole developer-facing surface. No VPC, no subnet group, no parameter group.
apiVersion: platform.acme.io/v1alpha1
kind: PostgreSQL
metadata:
  name: checkout-db
  namespace: checkout
spec:
  size: small

The failure modes are symmetrical: abstract too little and you shipped a thin wrapper over raw cloud APIs; abstract too much and every team files a ticket for the one field you hid. See Platform APIs & CRDs and IaC & Control Planes.

Measuring — the module that separates the two levels

Practitioner teaches you to build the MVP; Professional teaches you to prove it earned its keep. The honest version is boring and countable: how many teams are on the paved road, how long a change takes to reach production, and whose cost is whose.

# Adoption: how many teams are actually on the golden path?
# The grep drops apps carrying no team label, which would otherwise
# survive as a blank line and inflate the count by one.
kubectl get applications.argoproj.io -A \
  -l platform.acme.io/golden-path=http-service \
  -o jsonpath='{range .items[*]}{.metadata.labels.team}{"\n"}{end}' \
  | grep -v '^$' | sort -u | wc -l

# Lead time for change, straight from the platform's own telemetry (PromQL)
histogram_quantile(0.5,
  sum by (le, team) (rate(platform_deploy_lead_time_seconds_bucket[30d])))

# Cost per team — the number that makes an ROI conversation real
# (the kubectl-cost krew plugin, pointed at an OpenCost/Kubecost endpoint)
kubectl cost namespace --window 30d --show-efficiency=true

That last line is the kubectl-cost plugin reading from an OpenCost-style cost API rather than OpenCost’s own binary; the middle one is Prometheus. Every claim the ROI module asks you to make should trace back to a number like these — see FinOps and Observability.

How it maps onto the CNPE and onto this site

☺ Like you’re 10: The CNPE checks you can build it. This one checks you know what to build and how to get people to use it. Almost no overlap.

The CNPE is performance-based: a live cluster, real tasks, graded on the resulting state. This is multiple-choice: concepts, frameworks, judgement. They test opposite halves of the job and barely touch.

If you have worked through this site’s foundations track, you have already met roughly two-thirds of the Practitioner syllabus. The parts you have not — the ROI calculator, the stakeholder pitch, the pioneering-team playbook — are real, and genuinely underserved elsewhere.

Logistics, as published

☺ Like you’re 10: Roughly three hours a week for five to eight weeks, a one-hour test at the end, and it expires after a year.

Everything in this table comes from the official course pages linked at the end, as of writing. There is no exam code — these are not code-numbered vendor exams, and anyone quoting you one has invented it. Note also that the vendor does not publish a proctoring statement for these two exams the way it does for the Architect exam, so do not assume either way.

☺ Like you’re 10: The price is the real hurdle — this costs several times a hands-on cloud-native exam, and it expires faster.

At $1,800, one Practitioner seat is roughly four CKA-class exam sittings, or the CNPE plus a year of lab time. That is not an argument against it — live cohort teaching legitimately costs more than a proctored exam slot — but it is the trade you are making, and the one-year validity makes it a recurring one.

Verdict: where it fits in a realistic order

☺ Like you’re 10: Learn to build it first. Take this one later, ideally when your boss is paying.

Our honest recommendation, for the reader of this site:

First, build hands-on capability. CNPA if you are early, then CNPE, with CKA/CKAD in the mix if you lack them — the full ladder is on the certifications hub. These are the credentials employers screen on, they are performance-based, and they cost a fraction as much.

Second, do the free things: the free Introduction to Platform Engineering course (two hours, five modules, no exam — you get a completion badge, not a certificate — and genuinely decent), plus the other free courses now in the catalogue on GitOps, observability and Kubernetes lifecycle, and Platform as a Product, Team Topologies, Developer Experience, Best Practices and Anti-Patterns here. Do Panda’s exercise above for real.

Third — and only then — consider the Practitioner, ideally on a training budget and with two or three colleagues so the shared vocabulary takes root. Take the Professional only if you are personally accountable for a platform’s adoption and funding; its ROI and stakeholder modules are wasted on someone who isn’t in those meetings.

Skip entirely if you are paying your own way and choosing one credential this year. Buy the hands-on one. You can read a book about product thinking; you cannot read a book into being able to debug a cluster at 2 a.m.

Official sources re-verified for this page: Certified Practitioner, Certified Professional, Certified Leader, the Architect course (reached via the redirect from platformengineering.org/architect-certification, since its direct URL is cohort-dated), the Platform Engineering University catalogue and its FAQ, and the community’s about page. Prices, module titles, exam rules and validity above were read off those pages; nothing on this page is an inference about weights or domains, because the vendor publishes none. Compare against the CNCF ladder on our certifications hub and the exam mechanics in the CNPE exam guide.