CNPA practice test
Certified Cloud Native Platform Engineering Associate · free · 225 questions in the bank today
By Ibrahim Yesilay · Published · Updated
Start a free CNPA practice test: Certified Cloud Native Platform Engineering Associate questions with an instant verdict and explanation, an order that returns to your weakest domains, and a timed mock in the official format. The official CNPA exam is 85 questions in 120 minutes with a passing score of 75%, as read from the Linux Foundation documentation on 2026-10-28.
Ten guest answers need no account; mock exams need a free one. Independent practice, not affiliated with the CNCF or the Linux Foundation.
CNPA exam snapshot
Exam facts from the Linux Foundation pages, checked 2026-10-28; full table with sources on the CNPA certification page.
What this CNPA practice test is
This page starts a free CNPA practice session on GoldenKube. The official CNPA exam is 85 questions in 120 minutes with a passing score of 75%, as read from the Linux Foundation documentation on 2026-10-28. The GoldenKube CNPA bank held 225 questions when this page was written; the live count is shown above. One question at a time. As soon as you answer you see whether you were right and read the explanation; reloading the page keeps the verdict on screen. The next question comes from the questions due for review first, then from the domain where you are weakest and still have unseen questions, then from the rest of the bank. Use it next to the CNCF Platforms White Paper and the Platform Engineering Maturity Model: most questions describe an organisation or a platform setup and ask which principle, level or tool behaviour applies.
Every CNPA question in the bank has a written explanation, so a wrong answer is always followed by the reasoning that fixes it.
What the CNPA bank covers
The CNPA bank covers all six official domains and every one of the 27 curriculum competencies with at least eight questions, and each question is filed under the competency it practises. Platform Engineering Core Fundamentals holds the most questions; because of the per-competency minimum, the small developer-experience and platform-API domains hold a larger share of the bank than of the exam. The table compares the official domain weights, checked against the CNPA certification page on 2026-10-28, with the share of the bank each domain holds and the number of explained questions, both read from the database when the page is served. Platform Engineering Core Fundamentals is the heaviest domain at 36%, so it deserves the largest share of your study time whatever the bank's share is.
| Official domain | Exam weight | Bank share | Questions | Explained |
|---|---|---|---|---|
| Platform Engineering Core Fundamentals | 36% | 28% | 63 | 63 |
| Platform Observability, Security, and Conformance | 20% | 19% | 42 | 42 |
| Continuous Delivery & Platform Engineering | 16% | 18% | 40 | 40 |
| Platform APIs and Provisioning Infrastructure | 12% | 14% | 32 | 32 |
| IDPs and Developer Experience | 8% | 14% | 32 | 32 |
| Measuring your Platform | 8% | 7.1% | 16 | 16 |
All 225 questions have a written explanation. Live from the database; the CNPA bank coverage report explains the method.
A domain whose bank share is well below its weight is one to study from the official curriculum and the project documentation as well; the bank-coverage report linked below tracks these gaps over time.
How the bank covers the CNPA curriculum
The CNPA curriculum PDF lists 27 competencies across six domains, and the weights fall steeply: Platform Engineering Core Fundamentals carries 36% on its own, while IDPs and Developer Experience and Measuring your Platform carry 8% each. The GoldenKube CNPA bank follows the same order of size but not the exact shares: its 225 questions split into 63 for Core Fundamentals, 42 for observability and security, 40 for delivery, 32 each for platform APIs and for developer experience, and 16 for measurement, because every one of the 27 competencies carries at least eight questions. Every question is filed under one official domain and also under the competency it practises, using the curriculum's own names, which is why the cards below list topics rather than paraphrases.
Platform Engineering Core Fundamentals
36% of the exam · 63 questions in the bank
Why organisations build internal platforms, how declarative resources and environments are managed, and how DevOps, continuous integration and GitOps fit under a platform team.
Official curriculum topics
- Declarative Resource Management
- DevOps Practices in Platform Engineering
- Application Environments and Infrastructure Concepts
- Platform Architecture and Capabilities
- Platform Engineering Goals, Objectives, and Approaches
- Continuous Integration Fundamentals
- Continuous Delivery and GitOps
Platform Observability, Security, and Conformance
20% of the exam · 42 questions in the bank
Which telemetry signals a platform collects, how service-to-service traffic is secured, and how policy engines and Kubernetes controls keep workloads and pipelines within the rules.
Official curriculum topics
- Observability Fundamentals: Traces, Metrics, Logs, and Events
- Secure Service Communication
- Policy Engines for Platform Governance
- Kubernetes Security Essentials
- Security in CI/CD Pipelines
Continuous Delivery & Platform Engineering
16% of the exam · 40 questions in the bank
How pipelines hand changes to delivery, how GitOps workflows promote them across environments, and how a platform team responds when a release fails.
Official curriculum topics
- Continuous Integration Pipelines Overview
- Incident Response in Platform Engineering
- CI/CD Relationship Fundamentals
- GitOps Basics and Workflows
- GitOps for Application Environments
Platform APIs and Provisioning Infrastructure
12% of the exam · 32 questions in the bank
How the Kubernetes control loop, custom resources and operators let a platform offer infrastructure through its own declarative APIs.
Official curriculum topics
- Kubernetes Reconciliation Loop
- APIs for Self-Service Platforms (CRDs)
- Infrastructure Provisioning with Kubernetes
- Kubernetes Operator Pattern for Integration
IDPs and Developer Experience
8% of the exam · 32 questions in the bank
How developers find and consume platform capabilities through portals, catalogs and simplified interfaces, and where AI and ML automation enters the picture.
Official curriculum topics
- Simplified Access to Platform Capabilities
- API-Driven Service Catalogs
- Developer Portals for Platform Adoption
- AI/ML in Platform Automation
Measuring your Platform
8% of the exam · 16 questions in the bank
How to tell whether a platform is working: team productivity and efficiency measures, and the DORA software delivery metrics applied to platform initiatives.
Official curriculum topics
- Platform Efficiency and Team Productivity
- DORA Metrics for Platform Initiatives
Weights from the official certification page; question counts from the GoldenKube bank when this page was built; topics as named in the CNCF curriculum PDF listed under Sources.
The curriculum names topics, not products. The bank therefore asks about concepts first and uses CNCF projects such as Argo CD, Flux, Crossplane, Backstage, OpenTelemetry and Kyverno as examples of them; knowing one project per competency well is more useful than skimming all of them.
Because each competency has at least eight questions, the small domains are over-represented: IDPs and Developer Experience holds about twice its exam share of the bank, while Core Fundamentals holds less than its 36%. The mock exam draws its questions by the official weights, so use it, not the size of each domain in the bank, to judge the exam's balance.
Try three CNPA questions
Three questions from the bank with their answers and explanations. The CNPA sample-questions page has twenty more; the practice session has the whole bank.
Question 1
- A.The live state differs from Git, but the application's resources are running correctly.
- B.Live state matches the target state in Git, but the resources are not running correctly.
- C.The application is waiting for a manual sync to begin before its resources are created.
- D.Argo CD could not read the Git repository, so it shows the last known state instead.
Correct answer: B
Sources: CNCF CNPA curriculum (CNPA_Curriculum.pdf), Argo CD: Core concepts, Argo CD documentation
Question 2
Select all that apply.
- A.Mutable and Overwritable
- B.Pushed from CI on Every Merge
- C.Continuously Reconciled
- D.Pulled Automatically
Correct answers: C, D
Sources: CNCF CNPA curriculum (CNPA_Curriculum.pdf), OpenGitOps principles v1.0.0
Question 3
- A.Route every request through a weekly platform meeting, where the team decides on priorities.
- B.Offer each capability through several interfaces, such as IDE, CLI and web portal, by role.
- C.Expose the raw cloud provider consoles, so that users always see the real implementation.
- D.Offer exactly one interface for everything, so that every user learns the same single tool.
Correct answer: B
Sources: CNCF CNPA curriculum (CNPA_Curriculum.pdf), CNCF Platforms White Paper
How to practise CNPA with GoldenKube
CNPA is a reading exam more than a doing exam, so the loop alternates practice sessions with the two CNCF papers the curriculum rests on: the Platforms White Paper and the Platform Engineering Maturity Model. On the practice side GoldenKube serves due reviews first and fresh questions from your weakest domain next, and a miss comes back after 12 other answers, then a day later, then four days after that. Because each CNPA question is also filed under its curriculum competency, Focus mode can narrow a session to a single competency such as Kubernetes Reconciliation Loop rather than a whole domain. At 33 new answers a day the full bank is seen within a week.
The 7-day loop
- Day 133 answers with no filter, then read the Platforms White Paper sections on platform attributes and on measuring success.
- Day 2Reviews first, then Focus mode on Platform Engineering Core Fundamentals. Write the four OpenGitOps principles from memory and check them.
- Day 3Finish Core Fundamentals, the 36% domain, in Focus mode. Read the maturity model table and name the four levels in order.
- Day 4Focus on Platform Observability, Security, and Conformance. Note the three Pod Security Admission modes and what each does to a violating Pod.
- Day 5Focus on Continuous Delivery & Platform Engineering, then on Platform APIs and Provisioning Infrastructure; read the controller and custom resource pages on kubernetes.io.
- Day 6Focus on IDPs and Developer Experience and on Measuring your Platform; list the five current DORA metrics and which group each belongs to.
- Day 7One mock exam: 85 questions drawn from the bank, 120 minutes, scored against 75%. Read every explanation of a miss before stopping.
The 14-day loop
- Days 1-2About 17 answers a day without a filter while you read the Platforms White Paper end to end.
- Days 3-5Focus on Core Fundamentals over three days, one or two competencies per session, because it carries more than a third of the exam.
- Days 6-7Focus on observability, security and conformance; pair it with the OpenTelemetry signals page and the Pod Security Admission page.
- Days 8-9Focus on delivery and on platform APIs; read the Argo CD automated sync page and the Kubernetes operator pattern.
- Day 10Focus on the two 8% domains and read the maturity model detail for each aspect.
- Day 11First mock exam; write down the weakest domain from the by-domain result.
- Days 12-13Clear due reviews, then Focus mode on the weakest domain and the bookmarked questions you got right by guessing.
- Day 14Second mock exam; compare its by-domain result with the first.
The mock draws 85 of the 225 questions by the official domain weights, so two mocks in a row will share part of their items; treat the second as a pacing check rather than a fresh measurement. The first 10 practice answers need no account, and a free account keeps reviews, bookmarks and mock history for the whole loop.
Common CNPA mistakes
Most CNPA misses come from reading a principle as a rule: a platform as mandatory, a maturity level as a target, a metric as a goal. The rest come from defaults in the tools the curriculum uses as examples. Each item states what the linked official page says, read on 2026-10-28.
1. Treating the platform as mandatory
The Platforms White Paper lists "optional and composable" among the attributes of a platform: it must not be an impediment, product teams should be able to use only parts of its offerings, and they should be able to provide and manage their own capabilities outside its offerings when necessary.
2. Reading the maturity model as a ladder everyone must climb
The model has four levels (Provisional, Operational, Scalable, Optimizing) across five aspects (Investment, Adoption, Interfaces, Operations, Measurement). It states that no level is inherently good or bad, and that an organisation can sit at different levels in different aspects.
Source: CNCF Platform Engineering Maturity Model (TAG App Delivery)
3. Quoting the four keys as the current DORA model
The Platforms White Paper cites four DORA metrics, including time to restore service. DORA's current guide uses five: change lead time, deployment frequency and failed deployment recovery time measure throughput; change fail rate and deployment rework rate measure instability.
Source: DORA guide: DORA's software delivery performance metrics
4. Turning a DORA metric into a target or a league table
DORA lists setting metrics as a goal, relying on one metric, and comparing very different applications among its common pitfalls. The metrics are meant to be applied per application or service, and blending them across teams can mislead.
Source: DORA guide: DORA's software delivery performance metrics
5. Assuming Argo CD automated sync prunes and self-heals
By default automated sync does not delete resources that were removed from Git, and changes made directly to the live cluster do not trigger a sync. Pruning and self-healing are separate options that have to be switched on.
6. Thinking Pod Security warn or audit blocks a Pod
Only the enforce mode rejects a Pod that violates the selected standard. Audit adds an annotation to the audit log event and warn returns a warning to the user, but both let the Pod through, and a namespace can set different levels per mode.
7. Believing every custom API needs code
Kubernetes offers two ways to add custom resources: a CustomResourceDefinition needs no programming, while API aggregation needs programming but gives more control, for example over storage and version conversion.
8. Listing events as a stable OpenTelemetry signal
The curriculum topic names traces, metrics, logs and events. OpenTelemetry currently supports traces, metrics, logs and baggage, and lists events, a specific type of log, as under development or at the proposal stage.
Source: OpenTelemetry docs: Signals
Mock exam
The CNPA mock exam draws 85 questions from the bank, gives you 120 minutes and scores the run against the 75% threshold, the same numbers as the official format. It is a timed rehearsal of pacing and stamina, not a prediction: the questions are GoldenKube's own and the result is practice feedback. Mock exams need a free account; your history of runs is kept on the exam's mock page.
Frequently asked questions
Is the CNPA practice test free?
Yes. Your first 10 answers need no account. After that a free account keeps your progress; there is no paid tier and no card.
How many CNPA questions are there?
225 when this page was written; the live count from the database is shown at the top of the page. Questions are added and corrected over time.
Does the CNPA practice test match the real exam format?
The mock exam uses the published format: 85 questions, 120 minutes, 75% to pass. Practice mode is untimed and adaptive. The questions themselves are GoldenKube's own, not exam content.
Where are more sample questions with answers?
The CNPA sample-questions page shows 20 questions with answers and explanations without an account, and each CNPA topic page shows three more for its subdomain.
What are the levels of the CNCF Platform Engineering Maturity Model?
Four: Provisional, Operational, Scalable and Optimizing, described for five aspects (Investment, Adoption, Interfaces, Operations and Measurement). For Adoption, for example, they read erratic, extrinsic push, intrinsic pull and participatory. The model says no level is good or bad in itself; it depends on the team's goals.
How many CNPA questions does GoldenKube have per domain?
63 in Platform Engineering Core Fundamentals, 42 in Platform Observability, Security, and Conformance, 40 in Continuous Delivery & Platform Engineering, 32 in Platform APIs and Provisioning Infrastructure, 32 in IDPs and Developer Experience, and 16 in Measuring your Platform: 225 in total. Every one of the 27 curriculum competencies has at least eight questions, so the smaller domains hold a larger share of the bank than of the exam.
Which official documents should I read alongside the CNPA bank?
The CNCF Platforms White Paper and the Platform Engineering Maturity Model for the platform vocabulary, kubernetes.io for controllers, custom resources, operators and Pod Security, the OpenGitOps principles with the Argo CD and Flux docs for delivery, the OpenTelemetry signals page, and the DORA metrics guide for measurement.
Sources
- Certified Cloud Native Platform Engineering Associate (official certification page) (read )
- CNCF curriculum: CNPA Curriculum (PDF) (read )
- CNCF Platforms White Paper (TAG App Delivery) (read )
- CNCF Platform Engineering Maturity Model (TAG App Delivery) (read )
- DORA guide: DORA's software delivery performance metrics (read )
- Kubernetes docs: Controllers (read )
- Kubernetes docs: Custom Resources (read )
- Kubernetes docs: Operator pattern (read )
- Kubernetes docs: Pod Security Admission (read )
- OpenGitOps: GitOps Principles v1.0.0 (read )
- Argo CD docs: Automated Sync Policy (read )
- Flux docs: Core Concepts (read )
- OpenTelemetry docs: Signals (read )
- Crossplane docs: What's Crossplane? (read )
- Backstage docs: Backstage Software Catalog (read )
Last updated