Skip to content

CNPE hands-on labs

Labs: Preview

Certified Cloud Native Platform Engineer: exam-style tasks on a real kubeadm cluster on your own Mac, built and graded by the GoldenKube CLI. Each card shows the domain, the cluster topology it needs, the recommended time and its points; the scenario page has the full task text. Scenarios run on Kubernetes 1.35, the version the CNPE exam environment runs.

What the CNPE bank covers

The Linux Foundation describes CNPE as "an online, proctored, performance-based test" that "requires solving multiple tasks from within a Linux-based remote desktop using the terminal and web-based interfaces". The candidate instructions say "The exams consist of 15-20 performance-based tasks" and that "The CNPE environment is currently running Kubernetes v1.35"; the general documentation allowed is kubernetes.io. The GoldenKube CNPE scenarios run on a local Kubernetes cluster and are graded from the cluster state, so a task that the exam might solve in a web interface is written so that its result can be checked in the cluster.

The scenarios are written against the five official domains: networking, storage and compute best practices, right-sizing and multi-tenancy (platform architecture and infrastructure); GitOps workflows, CI/CD pipelines and progressive delivery such as blue/green or canary (GitOps and continuous delivery); custom resource definitions, self-service provisioning, operators and automation frameworks (platform APIs and self-service capabilities); monitoring, alerting, logging and tracing, deployment metrics and incident remediation (observability and operations); and service-to-service security, RBAC, audit trails and compliance, policy engines and admission control, and security scanning in pipelines (security and policy enforcement).

The CNPE exam, from the official pages

Questions15-20 performance-based tasks source
Duration (minutes)120 source
Passing score64% source
Price (USD)445 source
Validity (years)2 source
DeliveryOnline, proctored, performance-based source
PrerequisitesNone source
Retake policyOne retake per exam purchase if a passing score is not achieved source
Curriculum versionExam environment runs Kubernetes v1.35 source

Domain coverage

Published scenarios per official CNPE domain, next to the domain's exam weight (checked 2026-10-28 on the official page). 20 published scenarios today.

DomainExam weightPublished scenarios
Platform Architecture and Infrastructure15%
3
GitOps and Continuous Delivery25%
5
Platform APIs and Self-Service Capabilities25%
5
Observability and Operations20%
4
Security and Policy Enforcement15%
3

Mock exam mode

goldenkube exam cnpe draws a curriculum-weighted set: 15 tasks in 120 minutes, pass at 64%. Solutions and hints are hidden in exam mode.

Scenarios

13 of 20 scenarios match · Clear filters

CNPEPlatform APIs and Self-Service CapabilitiesMedium

Platform API: design a Database CRD with validation and status

Offer databases as a platform API: a namespaced CustomResourceDefinition with an enum-validated schema, a status subresource and printer columns, plus the first claim.

Single node · ~15 min · 10 points

  • crd
  • customresourcedefinition
  • openapi-schema
  • platform-api
  • self-service

goldenkube start cnpe-api-001

CNPEPlatform APIs and Self-Service CapabilitiesMedium

Operators: run Alertmanager through the Prometheus Operator

Use the Prometheus Operator as a platform automation: declare an Alertmanager and a namespaced AlertmanagerConfig, and confirm the operator reconciled them into a running, configured instance.

Single node · ~15 min · 8 points

  • operator
  • prometheus-operator
  • alertmanager
  • alertmanagerconfig
  • custom-resources
  • platform-automation

goldenkube start cnpe-api-003

CNPEPlatform APIs and Self-Service CapabilitiesMedium

Self-service namespaces: Kyverno generate rules for team onboarding

A team gets a working namespace by labelling it: a Kyverno ClusterPolicy generates the quota and the admin RoleBinding for every namespace carrying the team label and keeps them in sync.

Single node · ~15 min · 10 points

  • kyverno
  • generate
  • self-service
  • namespace-provisioning
  • policy
  • platform-api

goldenkube start cnpe-api-004

CNPEPlatform APIs and Self-Service CapabilitiesMedium

Automation framework: an Argo WorkflowTemplate that provisions environments

Offer environment provisioning as a reusable Argo WorkflowTemplate with a parameter and a resource step, then provision the blue environment through it.

Single node · ~15 min · 8 points

  • argo-workflows
  • workflowtemplate
  • automation
  • self-service
  • resource-template
  • platform-api

goldenkube start cnpe-api-005

CNPEPlatform Architecture and InfrastructureMedium

Multi-tenancy: quotas, defaults, priority and a tenant node pool

Two teams share one cluster. Give each namespace a ResourceQuota and LimitRange, add a tenant PriorityClass and pin a tenant workload to a dedicated node pool.

Two nodes · ~15 min · 11 points

  • multi-tenancy
  • resourcequota
  • limitrange
  • priorityclass
  • node-affinity
  • platform-architecture

goldenkube start cnpe-arc-001

CNPEPlatform Architecture and InfrastructureMedium

Cost management: OpenCost custom pricing, right-sizing and an HPA

OpenCost runs with list prices and the catalog service reserves far more than it uses. Load the on-prem price sheet into OpenCost, right-size the workload and let an HPA scale it.

Single node · ~15 min · 11 points

  • opencost
  • cost-management
  • right-sizing
  • hpa
  • helm
  • platform-architecture

goldenkube start cnpe-arc-002

CNPEPlatform Architecture and InfrastructureMedium

Storage and network baseline: a Retain default class and default-deny

Tenant data must survive claim deletion and tenants must be isolated by default. Make a Retain StorageClass the only default, bind the ledger claim to it and lock the namespace down.

Single node · ~15 min · 10 points · Storage

  • storageclass
  • persistentvolumeclaim
  • reclaim-policy
  • networkpolicy
  • default-deny
  • platform-architecture

goldenkube start cnpe-arc-003

CNPEGitOps and Continuous DeliveryMedium

GitOps with Argo CD: an automated Application from the platform repo

The shop manifests live in the in-cluster Git server. Deliver them with an Argo CD Application that creates its namespace, prunes and heals drift.

Single node · ~15 min · 10 points

  • argocd
  • gitops
  • application
  • self-heal
  • gitea
  • continuous-delivery

goldenkube start cnpe-git-001

CNPEGitOps and Continuous DeliveryMedium

Progressive delivery: blue/green with a preview service and manual promotion

Run checkout as an Argo Rollout with a blue/green strategy, verify the new version on the preview Service, then switch the active Service by promoting.

Single node · ~15 min · 8 points

  • argo-rollouts
  • blue-green
  • progressive-delivery
  • preview
  • continuous-delivery

goldenkube start cnpe-git-005

CNPEObservability and OperationsMedium

Monitoring and alerting: ServiceMonitor, alert and recording rule

Get the shop API into the platform Prometheus: scrape it with a ServiceMonitor, alert on its 5xx ratio and precompute its request rate with a recording rule.

Single node · ~18 min · 10 points

  • prometheus
  • servicemonitor
  • prometheusrule
  • alerting
  • recording-rules
  • observability

goldenkube start cnpe-obs-001

CNPEObservability and OperationsMedium

Tracing: add an OTLP traces pipeline to the OpenTelemetry Collector

The platform OpenTelemetry Collector only handles metrics. Give it an OTLP traces pipeline with the right processors, expose it, and prove it with generated spans.

Single node · ~18 min · 9 points

  • opentelemetry
  • otel-collector
  • tracing
  • otlp
  • telemetrygen
  • observability

goldenkube start cnpe-obs-002

CNPEObservability and OperationsMedium

Incident response: roll back a bad release and fix an OOM-killed workload

Two workloads in namespace checkout are degraded: diagnose a failed rollout and an OOM-killed container from events and status, remediate both in place and record the findings in an incident ConfigMap.

Single node · ~14 min · 10 points

  • incident-response
  • rollout
  • rollback
  • oomkilled
  • troubleshooting
  • observability

goldenkube start cnpe-obs-004

CNPESecurity and Policy EnforcementMedium

Guardrails: least-privilege RBAC for a CI identity and a Kyverno pod baseline

Give the CI service account exactly the rights it needs to roll out Deployments in one namespace, and enforce a pod baseline there with Kyverno: non-root containers and pinned image tags.

Single node · ~16 min · 11 points

  • rbac
  • kyverno
  • policy-as-code
  • admission-control
  • least-privilege
  • security

goldenkube start cnpe-sec-002

How a run works

  1. Install the CLI and Multipass, then run goldenkube doctor.
  2. Sign in with goldenkube login (free account).
  3. Start a scenario with its id; the CLI provisions a fresh cluster and prints the task.
  4. Solve it on the cluster, run goldenkube submit; the result appears on your dashboard.

Grading happens on your machine and is practice feedback, not an official score. Tasks are public; hints, reference solutions and grader internals are not.

Frequently asked questions

Can I run these CNPE labs today?

Not yet. The CNPE scenarios are published and readable here, but the first signed build of the CLI is not on the Homebrew tap, so the catalog is a preview. Running a scenario needs that release and a free account.

Which tools does the CNPE exam expect?

The CNPE curriculum names tools only as examples, among them Argo, Crossplane, Flux, Gatekeeper, Kyverno, OpenTelemetry, Prometheus and Tekton, and says candidates are not tested on deep tool-specific knowledge beyond the listed competencies. Each scenario page shows the full task text, so you can see what a task asks before you run it.

Do I need CNPA before CNPE?

No. The Linux Foundation lists no prerequisite for CNPE. CNPA is the multiple-choice platform engineering exam and covers much of the same vocabulary, so its GoldenKube question bank is a useful warm-up for the CNPE labs.

Sources