CGOA Study Plan
The CGOA blueprint tells you what the exam covers. This page tells you when to study each part, and for how long. Most study plans quietly assume every topic deserves the same slice of the calendar; CGOA punishes that assumption directly, because its five domains are not the same size — Principles (30%) and Terminology (20%) alone are half the paper, while Tooling, the domain most people assume is the whole exam, is worth only 14%. This plan takes fourteen days, cuts them by domain weight rather than by domain count, and hands you a day-by-day schedule, an hours budget, a study technique built around the exam's own core idea, and a final timed mock before you book the real thing.
Imagine your study time is a pizza, and you're cutting it into five slices — but not equal slices. You cut the slices the size of how many points each topic is worth. The "rules" slice is enormous, almost a third of the whole pizza. The "which tool does the pulling" slice is the smallest one, barely a sliver. If you cut the pizza into five equal pieces instead, you'd eat just as much of the tiny sliver as the giant slice — which means you'd under-study the big one and over-study the small one. This whole plan is just cutting the pizza correctly before anyone starts eating.
Spend the fourteen days where the marks are
☺ Like you're 10: Don't give every topic the same number of days. Give the big topics more days, and the small ones fewer — that's it, that's the whole trick.
The CGOA curriculum publishes five domains and their weights, and this plan does nothing more clever than turning that percentage straight into a day count and an hours budget. Read the full domain table and the four principles worked against a real example on the CGOA blueprint first if you haven't already — this page assumes you know what each domain covers and focuses purely on pacing it.
Turn those percentages into an actual hours budget and the shape gets concrete. Assume roughly 24 hours of pure domain study across twelve days (leaving the final two for revision, which isn't itself a scored domain), split by weight: 30% of 24h is 7.2h, 20% is 4.8h, 16% is 3.84h, 14% is 3.36h. Rounded to whole hours for a plannable week:
| Domain | Weight | Days | Hours (approx.) |
|---|---|---|---|
| GitOps Principles | 30% | 4 | ~7h |
| GitOps Terminology | 20% | 2 | ~5h |
| GitOps Patterns | 20% | 2 | ~5h |
| Related Practices | 16% | 2 | ~4h |
| Tooling | 14% | 2 | ~3h |
| Revision & timed mock | cross-cutting | 2 | ~4h |
Notice the day counts don't track the hours perfectly — Patterns and Tooling both get two days despite a 6-point weight gap. That's deliberate: a day is the smallest unit a calendar can hold, so once a domain's budget rounds below roughly a day and a half, it still gets a whole day, just a shorter one. The hours column, not the day column, is the number that actually reflects the exam.
A two-minute readiness check before day one
☺ Like you're 10: Fourteen days is a guess that fits most people. If you already use these tools every day, you can go faster. If none of this is familiar yet, give yourself more time.
Fourteen days assumes you're comfortable with containers and a basic Kubernetes mental model, and that GitOps as a word isn't brand new to you. Three quick checks before you commit to this exact calendar. If you already run Argo CD or Flux in production, you can likely compress this to ten days — most of Tooling and a chunk of Patterns is muscle memory you already have, so reclaim those days for Terminology drilling instead, since precise recall under exam pressure is a different skill than familiarity on the job. If GitOps is a name you've heard but never operated, stretch Week 1 to nine or ten days rather than six — the four principles need to feel obvious, not just memorized, before Patterns will make sense on top of them. If Kubernetes itself is still shaky, this plan isn't the place to start; CGOA doesn't test cluster mechanics directly, but every example on the exam is phrased in terms of Deployments, clusters and reconcilers, so a short detour through the sibling Kubernetes course pays for itself before day one here.
The 14-day schedule
☺ Like you're 10: Here's the whole two weeks on one strip — which days belong to which topic, at a glance.
The bar below is the table in the next section, drawn to scale. Block width is day count, not domain count — that's the entire point of a weighted plan.
| Days | Domain (weight) | What to do |
|---|---|---|
| 1–4 | Principles (30%) | Read GitOps Philosophy and the blueprint's principles section twice. Write all four principles from memory. Then invent three short workflows, each one deliberately breaking a different principle, and say which. |
| 5–6 | Terminology (20%) | Define all nine curriculum terms on a blank page, unprompted. Check every one against the glossary. Build them into flashcards and run one drill pass before day 6 ends. |
| 7–8 | Patterns (20%) | Read The Argo Ecosystem and Argo Rollouts. From memory, sketch pull vs. event-driven, and in-cluster vs. external reconciler, with one advantage for each option. |
| 9–10 | Related Practices (16%) | Be able to state "CI pushes, CD pulls" and defend it in one breath. Skim CaC and IaC as their own disciplines — Platform Engineering's IaC & control planes covers the neighboring ground CGOA borrows from. |
| 11–12 | Tooling (14%) | Put Argo CD and Flux side by side. Learn manifest formats — plain YAML, Kustomize, Helm, OCI — as shapes, not flags. Run the spot-the-violation drill below. |
| 13–14 | Revision & timed mock | Work the practice question bank, then sit Mock Exam · Set 1 under real time pressure. Re-read your weakest domain and rewrite the thirteen definitions cold before you book. |
Week 1 close-up — the half of the exam that's pure recall
☺ Like you're 10: Half the test is just remembering four rules and nine words correctly. No cluster needed — just your memory, tested honestly.
Principles and Terminology share one property that makes them worth front-loading: neither needs a keyboard. You can drill both on a train, in a waiting room, anywhere you can write or speak a sentence out loud. That portability is exactly why they belong in week one, before the schedule gets crowded with reading about tools.
A blank recall sheet does more for this domain than a re-read. Cover the definitions, then fill in only the left column from memory before checking the glossary:
MY DEFINITION (write this first, closed-book) → TERM _________________________________________________ → Declarative Description _________________________________________________ → Desired State _________________________________________________ → State Store _________________________________________________ → State Drift _________________________________________________ → State Reconciliation _________________________________________________ → Continuous _________________________________________________ → GitOps Managed Software System _________________________________________________ → Feedback Loop _________________________________________________ → Rollback MY WORDING OF EACH PRINCIPLE → PRINCIPLE _________________________________________________ → Declarative _________________________________________________ → Versioned and Immutable _________________________________________________ → Pulled Automatically _________________________________________________ → Continuously Reconciled
Every blank you can't fill in without peeking is a gap the exam will find before you do — mark it and re-drill it the next day, not the whole sheet.
Candidates who skim the principles instead of drilling them tend to answer "is this GitOps?" questions by checking only two boxes — declarative, versioned — and stopping there, because those two are the easiest to spot in a YAML snippet. The exam's favorite move is a workflow that's fully declarative and fully versioned, yet pushed by a CI job instead of pulled, and reconciled once per merge instead of continuously. Two out of four principles is not a partial pass on this question; it's a wrong answer. See the worked example on the blueprint if you want to see this scored line by line.
Week 2 close-up — patterns, practices, and the tools
☺ Like you're 10: The second week is where the words from week one get applied to real shapes and real tools — but the tools are still the smallest slice of the pizza.
Patterns (20%) is the most architectural domain on the paper: pull vs. event-driven triggers, in-cluster vs. external reconciler placement, monorepo vs. many-repo state stores. None of these are right-or-wrong choices in the real world — they're trade-offs, and the exam wants you to name the trade-off, not pick a winner. Related Practices (16%) asks how GitOps sits next to Configuration as Code, Infrastructure as Code, DevOps/DevSecOps and CI/CD without being any of them — the one sentence worth memorizing whole is CI pushes, CD pulls: a pipeline builds and publishes, then updates the store; the reconciler notices and converges, and the pipeline never touches a cluster credential.
Tooling (14%) is broad but genuinely shallow — manifest formats, state store systems, reconciliation engines, interoperability — and it rewards recognizing shapes over memorizing CLI flags. Here's a drill built from one deliberate omission. This Application is missing the field that would make it fully GitOps — find it before reading the comment:
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
name: telemetry-relay
namespace: argocd
spec:
project: default
source:
repoURL: https://github.com/example-org/fleet-config.git
targetRevision: main
path: apps/telemetry-relay/overlays/prod
destination:
server: https://kubernetes.default.svc
namespace: telemetry-relay
# syncPolicy is absent entirely — no automated block, so nothing pulls
# or reconciles on its own. Every sync here waits for a human to click
# "Sync" in the UI or run `argocd app sync` by hand.
#
# Which principle does that break? Pulled Automatically — a human
# triggering the action is not an agent pulling autonomously — and by
# extension Continuously Reconciled, since nothing is watching for
# drift between one manual sync and the next.
revisionHistoryLimit: 10Tooling being the smallest domain at 14% is the single most common surprise for people who assume "GitOps exam" means "Argo CD exam." It doesn't. The curriculum names Argo CD and Flux as examples, then says "and alternatives" — twice. Study the specification in week one and the tools in week two, in that order, and Tooling questions mostly answer themselves by elimination.
The daily study loop — read, drill, check, patch
☺ Like you're 10: Study the exact same way the exam's own robot works: check what you know against what you should know, fix only the gap, and do it again tomorrow.
Rather than inventing a separate study method, this plan borrows the exam's own idea and points it at your memory instead of a cluster. A reconciler doesn't re-apply everything on every pass — it compares actual state to desired state and closes only the difference. Do the same to your own recall each evening, and the sessions get shorter as the fortnight goes on, not longer.
In practice: read a section once, close the tab, and attempt the recall sheet or a flashcard pass from memory. Whatever you got wrong is your drift. The next session starts by patching only that — not re-reading the whole section again, the way most people default to. That's the entire efficiency gain this loop buys you over passive re-reading.
Set a timer for fifteen minutes. Open flashcards filtered to this course's GitOps deck and go through every card once, out loud, before looking at the answer. Anything you hesitate on for more than three seconds counts as a miss, even if you eventually got there — exam pace doesn't give you three seconds of doubt per question. Run this drill once a day from day 5 onward, not just in Terminology week; by day 14 it should take you less than ten minutes to clear the whole deck, and that drop in time is the actual measure of whether you're ready.
Final two days — revision and a timed mock
☺ Like you're 10: The last two days aren't for learning anything new. They're for finding out, honestly, whether the first twelve days actually worked.
Day 13: work through the CGOA practice question bank at a relaxed pace, untimed, and log every miss by domain rather than just by question — a cluster of misses in one domain tells you exactly where day 14's revision time should go. Day 14: sit Mock Exam · Set 1 under real conditions — ninety minutes, no notes, no pausing — then mark it honestly. If you clear it comfortably above the published 75% pass mark, book the real exam. If you're close but not comfortable, hold your booking, spend one more evening on whichever domain the mock exposed, and sit Mock Exam · Set 2 before you commit a date. A single mock score near the line is noise; two consistent scores above it is signal.
"I ran this exact schedule and nearly skipped the mock — I'd aced every flashcard pass by day 12 and felt done. The mock brought me back to earth: I'd nailed Principles and Terminology cold, but missed three Patterns questions in a row because I'd never actually sketched the in-cluster-versus-external trade-off, only read about it once. One evening redoing that sketch from memory fixed it completely. The two days I almost cut were the two days that told me the other twelve had actually worked."
(Composite, illustrative account — not a specific person's story.)
Exam-day logistics — and what to verify before you book
☺ Like you're 10: Once your two weeks are done, here's what booking the real thing actually involves — and a reminder to double-check every number before you pay.
These figures match the CGOA blueprint's own logistics table and come from the Linux Foundation's and CNCF's official CGOA pages, read in 2026.
| Item | Detail |
|---|---|
| Format & duration | Knowledge-based, multiple-choice, 90 minutes. No cluster, no terminal. |
| Delivery | Online, remote-proctored from your own machine — system check, room scan, photo ID. |
| Price | US$250 list, including one free retake (two attempts total). |
| Pass mark | 75%, per the Linux Foundation's Multiple Choice Exam FAQ — this plan's mock target above matches it exactly. |
| Eligibility & validity | 12 months to schedule and sit after purchase; the certification itself is valid for 2 years once passed. |
| Question count | Not published by the Linux Foundation or CNCF — treat any specific figure you see elsewhere as unverified. |
This is an independent, unofficial study resource — not affiliated with the CNCF or The Linux Foundation. Price, duration, retake terms, eligibility and validity windows, and the pass mark are all figures the Linux Foundation revises without much notice. Before you register or pay for anything, read the current official Linux Foundation CGOA page and the candidate handbook yourself. If anything on this page disagrees with them, they are right and this page is stale.
↗ Official CGOA page — Linux Foundation ◆ Multiple Choice Exam FAQ (pass mark)
Remy: Fourteen days sounds long for a ninety-minute test. Can't I just cram the night before?
Recon: BEEP. Thirteen definitions and four principles, unprompted, under time pressure. Cramming gets you recognition. The exam wants recall.
Gizmo: Or skip straight to the tools! Learn the Argo CD UI, memorize a few Flux flags, walk in confident. Tooling's a real domain! 😈
Timmy: Tooling is fourteen percent, Gizmo. Principles and Terminology together are fifty — and neither one touches a CLI flag.
Remy: Fifteen minutes a day, flashcards out loud, drop the ones I know cold. By day fourteen the whole deck takes under ten minutes.
Recon: Read, drill, check, patch. Same loop I run on a cluster. Turns out it works on a brain too.
1. Which two CGOA domains together make up half the exam, and how many of the fourteen days does this plan give them combined? 2. Why do Principles and Terminology come in week one rather than week two? 3. What are the four steps of the "read, drill, check, patch" study loop, and which exam concept does that loop deliberately mirror? 4. In the spot-the-violation drill, which field's absence breaks the Application, and which two principles does that break? 5. What score should a mock exam clear before you book the real thing, and what should you do if a single mock lands right on that line? 6. Name one CGOA exam detail that is not published anywhere by the Linux Foundation. 7. If you already run Argo CD or Flux in production, how might you reasonably shorten this plan, and where would you redirect the saved time?
Check your answers
- GitOps Principles (30%) and GitOps Terminology (20%) — 50% of the exam. This plan gives them six of the fourteen days (days 1–6), the largest combined block on the schedule.
- Because both are pure recall with no dependency on the tooling or patterns material covered later — studying them first means every later domain (Patterns, Related Practices, Tooling) gets read against a vocabulary that's already solid, instead of learning the words and the tools' details at the same time.
- Read (declare the desired knowledge state from the source material), Drill (attempt recall from a blank page, no notes), Check (compare recall against the source to find the gap), Patch (re-study only what was missed). It deliberately mirrors GitOps reconciliation itself: compare actual state to desired state, and converge only the drift.
- The
syncPolicy.automatedblock is missing entirely, so nothing syncs without a human clicking or running a command by hand. That breaks Pulled Automatically (a human triggers it, not an autonomous agent) and, by extension, Continuously Reconciled (nothing watches for drift between manual syncs). - 75%, the published CGOA pass mark, and comfortably above it, not just at it. If a mock lands right on the line, hold off booking, spend an evening on the domain the mock exposed, and sit a second mock — one score near the line is noise, two consistent scores above it is signal.
- The question count — neither the Linux Foundation nor the CNCF publishes it, so any specific number quoted elsewhere for it is unverified.
- Compress to roughly ten days, since much of the Tooling domain (and part of Patterns) is likely already familiar from daily use. Redirect the reclaimed days toward Terminology drilling — precise, unprompted recall under time pressure is a different skill from day-to-day familiarity with a tool.