CNPA Practice Questions — the bank

The CNPA is a knowledge-based, multiple-choice exam: nobody hands you a cluster, and nobody watches you type. What they hand you is a stem — a short scenario — and four options, exactly one of which is the best answer. That is a skill of its own, separate from knowing the material, and it is trainable. This page is the front door to the question banks: four per-domain sets, sixty-eight questions between them, sized roughly in proportion to the official blueprint. This page is not a quiz. It is the manual — how these questions are built, which traps they set, how to eliminate, what to do when a question names a tool you have never touched, how to spend the clock, and — the part almost everyone skips — how to review a bank afterwards so it teaches you something instead of merely scoring you.

How a CNPA question is actually built

☺ Like you’re 10: Every question has a little story, then one line that asks the real question, then four choices. Most people read the story and skip the line that matters.

Multiple-choice items on professional exams are not written casually. Each one is drafted by a subject-matter expert, reviewed by others, and then statistically checked against real candidates — if a question is answered correctly by strong and weak candidates at the same rate, it is doing no work and gets pulled. That process pushes questions in a very particular direction: away from “recall this fact” and toward “apply this idea to a situation, and tell the difference between it and the idea next door.” Understanding that shape is worth several marks on its own.

The three parts

A well-formed item has a stem (the scenario — facts, a constraint, usually a symptom), a lead-in (the single sentence that states what is actually being asked), and the options (one key and three distractors). The lead-in is where marks are won and lost, because it carries the qualifier: most directly, best, first, NOT, least likely. Two candidates who know the material equally well can split on a question purely because one of them read the lead-in twice and the other read it once.

Single best answer — not “the only true statement”

This is the single most important sentence on this page: the CNPA asks for the best answer, not the only correct one. On a well-written item, more than one option can be a true statement about the world. Only one of them answers the lead-in for this stem. Candidates who lose marks here usually lose them the same way — they find an option that is true, feel the small chemical hit of recognition, and click it without checking whether the remaining three are more true. Recognition is not the same as discrimination, and the exam is built to tell them apart.

Where the distractors come from

Distractors are not padding. They are harvested from the mistakes real practitioners make, which is why they feel so reasonable at speed. Across the CNPA blueprint, five families do nearly all the work:

Learn to spot the family and you shrink four options to two in a few seconds — which is the whole game, because the last decision is nearly always between two.

The four banks

☺ Like you’re 10: The questions are split into four piles, and the piles are the same sizes as the parts of the real test. The biggest pile is the one worth the most marks.

The CNPA blueprint has six weighted domains — 36 / 20 / 16 / 12 / 8 / 8 — and sixty-eight questions split across four banks, so each sitting stays short enough to finish in one go. The grouping is deliberate rather than arbitrary: Core Fundamentals is so large it gets a bank to itself, and the two pairs that share a bank share their ideas too. Continuous Delivery and Platform APIs are both, underneath, the reconciliation loop; IDPs and Measuring are both about the platform’s relationship with the developer who uses it.

Which bank to open first

Not the one you enjoy. Open Core Fundamentals first, always — it is 36% of the paper and it is the domain most people over-estimate themselves in, precisely because it is conceptual and every sentence in it sounds familiar. After that, let the results choose. A 70% in a 36-weight domain costs you roughly four times as much as a 70% in an 8-weight one, so fix in weight order rather than in the order the mistakes annoyed you.

The traps, named

☺ Like you’re 10: There are four tricks the question-writers use again and again. Once you can name a trick, it mostly stops working on you.

Traps are not unfairness — they are how a question separates “I have heard of GitOps” from “I understand what reconciliation does.” Here are the four you will meet most, each with a miniature example you can work in ten seconds.

The “most correct” trap

Two options are both true; the lead-in decides. The tell is a qualifier you skimmed: most directly, primary, best, first step, root cause. When you find yourself thinking “but two of these are right,” you have almost certainly misread the lead-in — go back and read it word by word, out loud if you are somewhere you can. Nine times out of ten there is a qualifier sitting there that you slid past, and it eliminates one of your two survivors instantly. The full dissection in the next section is an example of exactly this.

Negative phrasing

“Which of the following is NOT…”, “All of the following except…”, “Which is least likely…”. Your brain has spent the whole paper hunting for true statements, and negative items ask it to reverse polarity for one question only — which is why they catch people who actually know the material. The fix is mechanical: when you see a negative, mark each option T or F first, then pick the odd one out. Never try to hold the inversion in your head. Try it on this one:

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: checkout
  namespace: argocd
spec:
  source:
    repoURL: https://github.com/acme/platform-config.git
    targetRevision: main
    path: apps/checkout/overlays/prod
  destination:
    server: https://kubernetes.default.svc
    namespace: checkout
  syncPolicy:
    automated:
      prune: true
      selfHeal: true

Which of the following is NOT a consequence of this configuration? (A) A manifest deleted from Git causes the matching live resource to be deleted. (B) A manual kubectl edit on a managed resource is reverted. (C) A commit merged to main reaches the cluster without anyone running kubectl apply. (D) A commit is pushed to the repository whenever the cluster drifts from Git.

Mark them: A true (prune), B true (selfHeal), C true (automated), D false — reconciliation flows from Git to the cluster, and Argo CD does not write commits back. D is the answer, and you got there by labelling rather than by inverting. More on all three switches in GitOps workflows and Argo CD.

Absolute qualifiers

Real infrastructure is full of “usually”, “by default”, “unless configured otherwise”. So an option containing always, never, only, all, every, guarantees, eliminates is more often a distractor than a key — not as a law, but as a strong prior worth two seconds of suspicion. “A policy engine always blocks non-compliant workloads” is false the moment you remember Kyverno’s audit mode; “a service mesh eliminates the need for network policy” is false because they operate at different layers. Conversely, hedged language (“typically”, “can be configured to”, “in most implementations”) is quietly more likely to be defensible — which is exactly why examiners write keys that way.

Questions that test a distinction, not a fact

This is the CNPA’s signature move, and it follows straight from the blueprint: the syllabus is full of neighbouring concepts, so the questions are full of “which of these two is it?” You are rarely asked to define DORA; you are asked whether deployment frequency or lead time for changes is the metric that moves when a team merges to trunk more often. The defence is to keep a list of pairs and, for each, a one-line discriminator — the single sentence that tells them apart. Here are the pairs the CNPA leans on hardest:

Copy that table into your own notes and add a row every time a bank catches you out on a pair. By exam day the list is your revision sheet — it is far denser than any set of definitions, because a discriminator encodes two concepts and the boundary between them.

A worked example, dissected option by option

☺ Like you’re 10: We take one real question apart and show why each wrong door was built — including the sneaky one that is also true.

Reading “the answer is C” teaches you nothing. Reading why the other three exist teaches you the topic. So here is one full item, worked the way you should work every miss in the banks.

The question

A platform team keeps every Kubernetes manifest for the checkout service in a Git
repository. A CI workflow runs `kubectl apply -f ./manifests/` against the production
cluster on every merge to main, authenticating with a service-account token held as a
CI secret. On Tuesday, an on-call engineer runs `kubectl scale deployment/checkout
--replicas=10` directly against the cluster to absorb a traffic spike. The change is
still in place on Friday, and no alert or dashboard flagged it.

Which OpenGitOps principle does the survival of that manual change MOST DIRECTLY
show to be missing?

  A. Declarative
  B. Versioned and immutable
  C. Pulled automatically
  D. Continuously reconciled

Option by option

What the question was really testing

Not whether you can recite the four OpenGitOps principles — a flashcard does that. It tested whether you can map a symptom to the principle that explains it, while resisting a second option that is independently true. The discriminating move is a single question you can ask on any “most correct” item:

Note also what the examiner did not do: there is no trick wording, no ambiguity, nothing hidden. Every fact you need is in the stem, and the qualifier is capitalised. Good multiple-choice items are hard because the material is subtle, not because the sentence is. If you feel tricked, you have usually skipped a word.

Elimination — a four-move drill

☺ Like you’re 10: Answer in your own head first, then cross out the silly doors, then choose between the last two on purpose — not by vibes.

Elimination is not what you do when you are stuck. It is the default procedure, run on every question, including the ones you think you know. It costs about fifteen seconds and it catches the questions where you are confidently wrong — which are the only ones that actually cost you marks.

Move one — answer before you read the options

Read the stem, read the lead-in, and form your own answer before your eyes reach option A. This is the highest-value habit on this page, because a well-built distractor is designed to be attractive once you have seen it. If you arrive with an answer already in hand and it appears in the list, you are usually done in fifteen seconds and you have spent no attention on the traps. If your answer is not in the list, that is valuable information too — it means you have misread the lead-in or misjudged the scope, and you should re-read before doing anything else.

Move two — kill on qualifier, layer and category

Three cheap sweeps, in this order. Qualifier: flag every always / never / only / all / guarantees and check that claim first. Layer: ask which point in the lifecycle the option acts at — commit, build, admission, runtime, or after the fact — and drop anything at the wrong point (a pipeline scan cannot stop a Pod someone applied by hand; only admission control can). Category: drop anything that puts a tool in the wrong box — Prometheus is not a tracing backend, Crossplane is not a policy engine, Backstage is not a CD controller. Two of the four options usually die here.

Move three — the last two

Now slow down; this is where the mark is. Put the two survivors side by side and find the words that differ — often it is one: all vs some, before vs after, desired vs actual, deployment frequency vs lead time. Then re-read the lead-in and ask which of the two answers that sentence. If both still survive, apply the repair test from the worked example: fix each one and see which removes the symptom. If they still both survive, prefer the option that is tied to the specifics of the stem over the one that would be true in any scenario — keys are written for their stem; generic distractors are recycled.

Move four — commit, then let go

Answer every question. Nothing published indicates that Linux Foundation multiple-choice exams deduct marks for a wrong answer — treat that as an assumption to confirm in the candidate handbook rather than a fact you got here — but even under negative marking, a considered guess between two survivors is a coin flip you should take. Then genuinely let it go. Ruminating on question 12 while reading question 13 is how one uncertain answer becomes three.

When the question names a tool you have never used

☺ Like you’re 10: If you don’t know the animal, work out what kind of animal it is. You can answer “does it eat grass?” without ever meeting that exact one.

It will happen, and it is far less dangerous than it feels. The CNPA tests concepts and patterns, not tool trivia — it does not ask which flag a CLI takes. So a question that names an unfamiliar project is nearly always asking a question about its category, and you can answer a category question about a tool you have never installed.

Step one — put the tool in a box

Almost everything the CNPA can name falls into one of six boxes. Learn the boxes and the membership, and the tool surface of the exam collapses to something you can hold in your head:

Step two — answer the category, not the tool

Once the tool is in a box, re-read the options and ask which one is consistent with what that box does. Three of the four will usually describe a different box, and the question dissolves. If two options both fit the category, fall back on the stem: the key is the option that solves the problem the scenario actually describes. And if the tool is genuinely unplaceable, ignore it entirely and answer the underlying concept question — you will be right more often than you expect, because the concept is what was being tested all along.

Afterwards, do the cheap repair: look it up in the glossary, find it on the CNCF landscape map, and skim the tools index. One paragraph per unfamiliar name, filed by box, closes this gap permanently in an evening.

The clock, and flagging discipline

☺ Like you’re 10: Work out how long you get per question, keep a bit of time spare at the end, and don’t sit staring at the hard ones — mark them and come back.

Time pressure on a knowledge-based paper is mild compared with a performance exam, but it is real, and it turns knowledge into marks only if you manage it. The arithmetic is trivial and you should do it before you start.

Work out your own budget

One of those two numbers is published and the other is not. The Linux Foundation’s Multiple Choice Exam FAQ gives CNPA candidates 120 minutes — naming the CNPA as the exception to the 90 minutes its other multiple-choice exams get — and sets the pass mark at 75%. It states no question count, for the CNPA or for any other exam, and no official page publishes one; the 60 questions our papers use is a study convention of this site, not a published figure. Re-check that FAQ on the day you register — figures do get revised — and keep our own CNPA overview page (internal) for study context rather than for booking facts. To build a budget, do this: divide the total minutes by however many questions you are actually sitting, subtract roughly ten minutes of the total for a review pass, and use the remainder as your first-pass budget per question. Then split questions into three tiers as you go — under 30 seconds (you know it: answer, move), around your budget (work the elimination drill), and over 1.5× your budget (flag, best guess recorded, move immediately). For drilling these banks, use two minutes per question as a working pace: it is what 120 published minutes across a 60-question convention works out to, and it is a rhythm that leaves room to eliminate properly rather than skim.

Flag rules

Assume you can mark a question and return to it — the Linux Foundation’s multiple-choice exams generally allow navigation and review, and the candidate handbook on the official page is the current word on the interface. The discipline matters more than the mechanism:

• Always record an answer before you flag. A flagged blank is a zero if the clock beats you; a flagged guess is a coin flip you already banked.
• Flag only for a reason you can name — “eliminated to two and guessed”, “didn’t know the term”, “misread it twice”. “Felt uneasy” is not a reason; it is anxiety, and it will flag half the paper.
• Cap it at roughly one question in seven. If you are flagging more than that, the flag has stopped being a tool and become a way of deferring the discomfort of committing.
• On the review pass, change an answer only if you can state what changed. A missed qualifier, a misread lead-in, a fact recovered later — those are reasons. The folk rule “never change your first instinct” is not a law, but neither is second-guessing: the deciding factor is whether you can articulate why.
• Stop when the clock says stop. Re-reading the same two survivors for the fifth time does not add information; it only adds fatigue to the questions you have not seen yet.

Reviewing a bank so it teaches instead of scores

☺ Like you’re 10: The score is the least interesting thing. What matters is why you got each one wrong — there are only four reasons, and each has a different fix.

Here is the mistake nearly everyone makes: finish a bank, look at the percentage, feel good or bad about it, and move on. That converts an hour of work into a single number carrying almost no information. The score tells you whether you have a problem; only the review tells you what it is — and the fix for “I didn’t know that” is completely different from the fix for “I knew that and misread the question.”

The four buckets

Every miss goes in exactly one bucket. Be honest — the temptation is to file real gaps as carelessness because it stings less, and that is how the same question catches you again in the mock.

The mix matters more than the count. Mostly bucket 1 means you are simply not ready in that domain — go and read, do not drill. Mostly bucket 3 means you know the material and are losing marks on boundaries, which is the fastest thing on this page to fix. Mostly bucket 2 or 4 means your technique is the problem, and re-reading the domain pages will not move your score by a single point.

The miss log

Keep it in a file, not in your head — the whole point is that it survives until the re-sit. A five-column CSV is enough, and plain text means you can sort and count it:

mkdir -p ~/cnpa-prep
printf 'date,bank,domain,question,bucket,one-line-fix\n' > ~/cnpa-prep/misses.csv

Append one line per miss — the “one-line fix” is the sentence you would tell a colleague, not a copy of the explanation. Writing it yourself is the part that does the learning:

printf '%s\n' "2026-07-22,core,fundamentals,q14,confused,CD = releasable + human gate; deployment = automatic to prod" >> ~/cnpa-prep/misses.csv

Then read it back two ways. Which bucket dominates tells you whether to study or to change technique; which domain dominates tells you where the marks are leaking, and should be weighed against that domain’s blueprint weight:

column -s, -t ~/cnpa-prep/misses.csv

tail -n +2 ~/cnpa-prep/misses.csv | cut -d, -f5 | sort | uniq -c | sort -rn

tail -n +2 ~/cnpa-prep/misses.csv | cut -d, -f3 | sort | uniq -c | sort -rn

Spacing the re-sit

Do not re-take a bank the same evening. A second pass an hour later measures short-term memory and will flatter you badly — you will remember “it was the one about drift” without recovering the reasoning. Leave 48 hours, re-sit cold, and treat any question you miss twice as a content gap regardless of which bucket you filed it in the first time. Strike a question off your list only when you can state the key and name why each distractor was built. That is the standard, and it is a high one: a bank you have truly finished is one you could write the explanations for yourself.

How the banks fit your study plan

☺ Like you’re 10: Read the chapter, then do that chapter’s questions, then fix what you missed. Save the big practice test for the very end.

Sequence matters more than volume. The banks are a middle step, not a beginning and not an end — put them between reading and the full mock and they do a job nothing else does; use them first and you will just memorise questions.

The CNPA study plan lays that out week by week and tells you which bank belongs to which week; the CNPA hub maps every domain to both the associate page and the deeper CNPE lesson behind it. Alongside the banks, the shared revision kit still applies: the flashcards for the facts, the self-check quiz for a mixed warm-up, the glossary for every term you meet in an explanation, and what to know cold for the short list you should be able to produce without thinking.

How the banks and the four mock papers relate

Honestly: they overlap, on purpose. The two do different jobs — the banks drill one domain at a time, untimed, so you can stop and argue with a distractor; the four mock papers (Set 1, Set 2, Set 3, Set 4) rehearse the whole weighted paper under the clock. But they are drawn from the same syllabus, and a syllabus whose largest domain is 36% cannot supply four papers plus four banks of entirely separate propositions. So the core ideas — what a platform is, declarative versus imperative, golden paths, the reconciliation loop — recur across both, reworded.

That is a feature you should use rather than a duplication you should route around. Meeting the same proposition in a bank on Tuesday and in a mock paper the following week is spaced retrieval, and for a knowledge-based exam that is precisely how recall becomes durable. Treat recognition as a reading on your own state: if the answer is instant, the idea has consolidated; if you hesitate, or get it wrong a second time, it was never as solid as the first score implied — and that item belongs at the top of your miss log.

Counting honestly, the site holds 4 mock sets of 60 (240) plus 4 banks totalling 68 — 308 question instances, covering a smaller number of distinct propositions. Do not plan as though it were 308 unrelated ideas.

Now go and open a bank. Start with Core Fundamentals, keep the miss log next to you, and remember the standard Owl set: you have not finished a question until you can explain why the other three doors were built.