The CNPE Exam — format, registration & a study plan

The Certified Cloud Native Platform Engineer (CNPE) is a hands-on, performance-based exam: no multiple choice, just real tasks on a real cluster with a ticking clock. This page is your logistics briefing — what the exam is, how to register and what it costs, the five domains by weight, the tools you might meet, how CNPE differs from its associate cousin CNPA, a ten-week study plan mapped to this site, and the terminal-speed habits that win points on the day. Treat the numbers here as “true at time of writing” and confirm the live details on the official pages before you pay. For the human side of it — what people who sat the exam say it actually felt like — read the companion page, Field Notes — how people actually passed.

What the CNPE actually is

☺ Like you’re 10: It’s a two-hour, “do it for real” test on a live cluster — a proctor watches through your webcam, and you solve tasks instead of answering questions.

The CNPE was launched by the CNCF and The Linux Foundation in late 2025 as the senior, hands-on credential for platform engineers — the person who builds the internal developer platform, not just the person who uses it. It sits above the associate-level CNPA and targets an intermediate-to-senior audience: Principal Platform Engineers, Platform Architects, and SRE/DevOps leads who design golden paths for other teams.

The exam is performance-based and online proctored. You work inside a Linux remote desktop with a terminal and a browser, connected to one or more live Kubernetes clusters, and you complete a series of real tasks — configure GitOps, wire a pipeline, write a CRD, set an alert, apply a policy — that are graded on the resulting cluster state, not on how you got there. There are no multiple-choice questions. A remote proctor supervises through your webcam for the full 120 minutes.

Registration & logistics

☺ Like you’re 10: You buy the exam online, you get up to a year to take it, and you need a quiet room, a webcam, and an ID that matches your name.

You register through the Linux Foundation training portal (linked from the CNCF certification page). Payment is $445 and includes one free retake, so a first-attempt miss isn’t the end of the world. When you buy, you also unlock two sessions of the killer.sh simulator — a harder-than-real practice environment you should treat as part of the exam, not an afterthought.

Three official pages are your source of truth for pricing, policy, and the rules of the room. The third — Important Instructions: CNPE — is the one candidates most often skip, and it’s where the task count, the environment versions, and the allowed-resources rules actually live. Read it end to end the week before you sit:

↗ Register at the Linux Foundation ◆ CNCF certification page ◆ Important Instructions: CNPE

The five domains & their weights

☺ Like you’re 10: The test spends more time on some jobs than others. GitOps and self-service are each a quarter of the score — so those are where you practise hardest.

The CNPE blueprint splits the platform engineer’s craft into five weighted domains. The bars show how much of the exam each one is worth — your map for where to spend study time. Each links to its lesson on this site:

Half the exam — a full 50% — lives in the two 25% domains, and both are hands-on to the bone: standing up GitOps with Argo CD or Flux and shipping safely with progressive delivery, then exposing CRDs, operators and self-service provisioning. Don’t neglect the smaller domains, though: at 15% each, architecture and security & policy are still worth real points, and their tasks are often quick wins if you’ve practised.

The tools you may see

☺ Like you’re 10: There’s a set of real tools the exam draws from — but you’re not quizzed on trivia. If you meet an unfamiliar one, you’re expected to read its docs and figure it out.

The official curriculum names 15 projects the exam may use. The important caveat, straight from the curriculum: you will not be tested on deep tool-specific knowledge unless it’s referenced in the competencies. You’re a platform engineer, so you’re expected to use the documentation for a tool you don’t know by heart — reading docs fast under time pressure is itself a tested skill. One caution before you lean on that: the CNPE allowlist covers the Kubernetes docs and blog, whatever the task’s Quick Reference box links, and locally installed docs and man pages — not the project websites for Argo CD, Crossplane, Prometheus, OpenTelemetry, Backstage or Helm. See the allowlist note further down. Here they are, grouped by where they tend to appear:

That’s all fifteen: Argo, Crossplane, Flagger, Flux, Gatekeeper, Grafana, Istio, Jaeger, Kyverno, Linkerd, OPA, OpenCost, OpenTelemetry, Prometheus, and Tekton. For a one-page tour of what each does and the job it maps to, see the tool landscape. The rock-solid foundation under all of them is plain kubectl and the core Kubernetes API — that fluency is assumed, so it’s the one thing worth over-practising.

CNPE vs CNPA — which is which

☺ Like you’re 10: CNPA is the “do you know the words?” beginner test. CNPE is the “can you actually build it?” senior test.

The CNCF pairs a foundational associate cert with the professional one. The CNPA (Certified Cloud Native Platform Engineering Associate) is knowledge-based and aimed at people newer to the field; the CNPE is the senior, hands-on credential. CNPA isn’t a prerequisite, but it’s a sensible warm-up — and the concepts overlap heavily with the foundations on this site.

A ten-week study plan

☺ Like you’re 10: There’s a full week-by-week plan with labs and checkpoints — it lives on its own page so it has room to breathe.

A good CNPE plan is simple to describe even though it takes weeks to run: weight your study hours by domain percentage — the two 25% domains (GitOps and Platform APIs & Self-Service) get the most time, the two 15% domains get the least — pair every topic with a hands-on lab on a throwaway cluster, and finish by burning both killer.sh sessions plus a full timed mock. Reading about kubectl is not the same as your fingers knowing it, so the plan is built around doing, not reading.

The full ten-week, domain-by-domain plan — with a lesson-and-lab pairing for every week, a resource list, and a readiness checkpoint — lives on its own page: the CNPE study plan.

Exam-day & terminal-speed tips

☺ Like you’re 10: Small habits save minutes: always check which cluster and namespace you’re in, let the computer type the boilerplate for you, and check your work before you move on.

Points are won and lost on speed and precision, not cleverness. These habits are worth drilling until they’re automatic — the goal is that on the day, your hands move while your brain reads the next task.

# 1) Switch to the cluster the task names — do this FIRST, always
kubectl config use-context cluster-name

# 2) Pin the namespace so you stop typing -n everywhere (and stop forgetting it)
kubectl config set-context --current --namespace=team-payments

# 3) A tiny alias kit pays for itself in the first ten minutes
alias k=kubectl
export do='--dry-run=client -o yaml'   # usage: k create deploy web --image=nginx $do > web.yaml
export now='--force --grace-period=0'   # usage: k delete pod broken $now

# 4) Let the cluster generate boilerplate instead of hand-writing YAML
kubectl create deployment web --image=nginx --replicas=3 $do > web.yaml
kubectl create configmap app-cfg --from-literal=LOG=debug $do > cfg.yaml

# 5) When you don't remember a field, ask the API — no docs tab needed
kubectl explain deployment.spec.template.spec.containers.resources

Reach for imperative generators (kubectl create … --dry-run=client -o yaml) to produce a skeleton you then edit, rather than typing manifests from scratch — it’s faster and it won’t fumble indentation. Use kubectl explain to recall a field’s exact path. And know your allowed documentation — the list is narrower than most candidates assume.

What test-takers report

☺ Like you’re 10: People who’ve taken it all say roughly the same thing — the clock is the enemy, not the questions. Be quick, don’t get stuck, and finish something on every task.

The following comes from published first-hand accounts by candidates — blog write-ups of their own sittings, not official Linux Foundation guidance. Individual experiences vary and none of it is a promise about your exam form. But the same handful of lessons keeps surfacing, which is usually a sign they’re real:

• Docs are open, so navigation speed matters more than memorisation. Nobody reports being caught out by a fact they hadn’t memorised. They report losing minutes hunting for the right page. Practise finding things in kubernetes.io/docs — and remember the allowlist above means everything outside it has to come from your head or from kubectl explain.
• Unfamiliar tooling is the biggest time trap. The single most repeated warning: when a task uses something you haven’t touched, don’t improvise from first principles and don’t stare at it. Go to the documentation immediately. Curiosity is expensive at 120 minutes.
• Flag anything over roughly 5–7 minutes and move on. Candidates who finished consistently describe a hard personal time-box per task. The ones who ran out of time describe sinking twenty minutes into one stubborn item.
• Read all the tasks first, then do the easy ones early. A fast opening pass tells you where the cheap points are and quietly lets your brain chew on the hard ones in the background.
• Partial credit means an unfinished exam can still pass. With a 64% cut score, you do not need to complete everything. Several accounts describe passing with tasks left untouched. Getting most of the way through many tasks beats perfecting a few.
• Some tasks allow tool choice, and GUI or CLI. Where a task doesn’t name a tool, use the one you’re fastest with — and don’t assume the terminal is always quicker; for some web-UI work, clicking wins. You’re graded on the resulting state, not your method.

We’ve collected these accounts, with who said what, on the companion page: Field Notes — how people actually passed.

Your path through this site

☺ Like you’re 10: Every part of the exam has a matching lesson here — read the lesson, do the lab, then test yourself with the quiz and flashcards.

This whole course is built around the exam blueprint, so the mapping is direct. Domain 1 is Platform Architecture & Infrastructure. Domain 2 splits across GitOps Workflows and CI/CD & Progressive Delivery. Domain 3 spans Platform APIs, CRDs & Operators and Self-Service & Portals. Domain 4 is Observability & Operations, and Domain 5 is Security & Policy. Wrap them with the operating-model lessons — anti-patterns and best practices — and the tool landscape.

When you’re ready to test yourself, the Practice & Reference shelf is your revision kit: the printable exam-prep checklist to make sure nothing’s missed, flashcards for quick recall, a self-check quiz, and a searchable glossary for any term that trips you up. Loop: read a lesson, run its lab, then quiz yourself — repeat until the checklist is all ticks.

Nerves are normal — the antidote is reps. Work the ten-week plan, run every lab, and burn both simulator sessions, and you’ll walk in already knowing you can do the work. Now go pick your start point: the foundations if you’re new, or straight into GitOps if the fundamentals are solid. And when you want to hear it from people who’ve already sat in that chair, spend twenty minutes with Field Notes — how people actually passed.