CGOA course and practice exam: Certified GitOps Associate
This CGOA course has 30 video lessons and 69 graded labs, and its CGOA practice exam follows the official exam objectives: a 20-question sampler free with an account, the full question bank and timed mock exams with Pro.
GitOps terminology, principles, patterns and tooling
Prepares you for CGOA: GitOps terminology and principles, related practices, patterns and tooling.
Beginner · 2 hours · 30 lessons · 69 labs
CGOA exam guide
The CGOA exam (Certified GitOps Associate, by CNCF / The Linux Foundation): 90 minutes; pass mark: 75%; cost: USD 250 (includes one retake); USD 495 bundled with the course.
- Format: Online, proctored, multiple-choice
- Duration: 90 minutes
- Questions: not published
- Pass mark: 75%
- Cost: USD 250 (includes one retake); USD 495 bundled with the course
- Valid for: 2 years
- Delivery: Online, proctored (PSI)
- Prerequisites: None
Exam domains and weights
- GitOps Terminology: 20%
- GitOps Principles: 30%
- Related Practices: 16%
- GitOps Patterns: 20%
- Tooling: 14%
A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.
10 CGOA sample questions with answers: free to read, no account needed.
Common questions
How long is the CGOA exam?
The CGOA exam lasts 90 minutes.
What is the CGOA passing score?
The pass mark is 75%.
How much does the CGOA exam cost?
USD 250 (includes one retake); USD 495 bundled with the course.
Is there a free CGOA practice test?
Yes. A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.
Source: CGOA exam page (Linux Foundation Training), domains, weights and competencies (CNCF / The Linux Foundation), checked 2026-10-03.
Who it is for
Beginner level.
For anyone preparing for the Certified GitOps Associate exam: engineers, team leads and others who work with teams that release software by keeping its settings in Git.
What you don't need yet:
- No GitOps or Argo CD experience
- No cluster or cloud account of your own
- No command line: every hands-on task is done in the page
What helps:
- A little Kubernetes: what a cluster and its running copies (replicas) are
No formal prerequisites. The courses under "Take first" cover what helps.
Take first:
Take next:
- Certified Argo Project Associate (CAPA) Exam Prep — Intermediate
Learning paths:
Nobody needs to know everything before they start. Each course builds on the one before, so a learning path takes you there step by step.
What this exam proves, and what it doesn't
CGOA is an online, proctored, multiple-choice exam: passing shows you understand GitOps principles and practice. It doesn't test hands-on skill or replace running GitOps in production; our graded labs have you work through real tasks in the page.
Exam objectives this course teaches
Certified GitOps Associate (CGOA)
- GitOps Terminology (20% of the exam): Continuous; Declarative Description; Desired State; State Drift; State Reconciliation; GitOps Managed Software System; State Store; Feedback Loop; Rollback
- GitOps Principles (30% of the exam): Declarative; Versioned and Immutable; Pulled Automatically; Continuously Reconciled
- Related Practices (16% of the exam): Configuration as Code (CaC); Infrastructure as Code (IaC); DevOps and DevSecOps; CI and CD
- GitOps Patterns (20% of the exam): Deployment and Release Patterns; Progressive Delivery Patterns; Pull vs. Event-driven; Architecture Patterns (in-cluster and external reconciler, state store management, etc.)
- Tooling (14% of the exam): Manifest Format and Packaging; State Store Systems (Git and alternatives); Reconciliation Engines (ArgoCD, Flux, and alternatives); Interoperability with Notifications, Observability, and Continuous Integration Tools
Labs
69 labs, 69 of them graded: you write the code, it runs, and graded labs check the result. The outline lists each lesson's labs.
What is free
Start free: First module free with an account. Pro: Every course, lab, handbook, practice exam and certificate.
- Pro monthly — $29 a month. Every course, lab, handbook, practice exam and certificate
- Pro yearly — $249 a year. Every course, lab, handbook, practice exam and certificate
Course outline
Start Here
- A Hotfix At 3 A.M.: Who Wins At 3:05? (2 labs): You can describe desired state, actual state, drift and reconciliation with a real timeline, predict what a GitOps agent does to a change made by hand, and name the four OpenGitOps principles.
- Half The Marks Are Definitions: How The Exam Works (3 labs): You know the CGOA exam's published facts, can turn a diagnostic into a study order weighted by domain, pace a ninety-minute paper in three passes, and eliminate options by wrong word, level, owner or scope.
GitOps Terminology
- Staging Is Gone: Desired State, Declarations And The State Store (2 labs): You can state the OpenGitOps definitions of desired state, declarative description and state store, sort real artefacts into desired state or not, and turn an imperative command into a stored, versioned declaration with kubectl and git.
- Three Edits At 2 A.M.: Drift And Reconciliation (2 labs): You can define drift and reconciliation in the OpenGitOps glossary's words, predict which hand edits an agent reverts on a simulated cluster, explain why undeclared fields never drift, and tell the two kinds of divergence that trigger a reconcile.
- Sixteen Pods, Room For Twelve: The System, Feedback And Continuous (2 labs): You can list the three parts of a GitOps managed software system, check a real platform against them, explain feedback in the closed-loop sense the glossary uses, and say what "continuous" does and does not require.
- Two Ways Back From 2.5: Rollback The GitOps Way (2 labs): You can roll back by returning the desired state to an earlier version with a real git revert and a reconcile, explain why a rollback made in the cluster is undone as drift, why reset and force push break the principles, and what an automatic rollback leaves in the state store.
- Terminology Sprint: One Incident, Nine Terms (3 labs): You can name the glossary term behind each event of a real incident, answer eight terminology questions at exam pace, and spot the five traps this domain sets.
GitOps Principles
- Seven Steps Called GitOps: The Declarative Principle (2 labs): You can quote the declarative principle, audit a pipeline for steps that break it, show with a real run why declarations are comparable, idempotent and convergent while commands are not, and tell declarative inputs from procedures.
- Someone Cleaned Up The History: Versioned And Immutable (2 labs): You can quote the Versioned and Immutable principle, show with real git how a protected store refuses a history rewrite and accepts a revert, explain why mutable image tags undermine versioning, and list what a complete history pays for.
- Twelve Keys To Production: Pulled Automatically (2 labs): You can quote the Pulled Automatically principle, count the credentials push and pull expose, compare the two on network direction, missed deploys and drift with a simulated timeline, and tell which pushes a GitOps system still allows.
- An Hour Without Payments: Continuously Reconciled (2 labs): You can quote the Continuously Reconciled principle, predict repair times from an agent's interval, write and test a reconcile loop that converges and is idempotent, and choose intervals, retries, webhooks and jitter for a workload.
- Principles Sprint: Six Setups, One Question (3 labs): You can decide whether a delivery setup is GitOps by testing the four principles in order, name the first one that fails, handle the cases where the principles blur, and answer eight principles questions at exam pace.
Related Practices
- Two Clicks Nobody Wrote Down: Configuration And Infrastructure As Code (2 labs): You can define configuration as code and infrastructure as code, generate content-named configuration with real Kustomize, read an infrastructure plan that finds drift, explain where GitOps adds pull and reconciliation, and keep secrets in a repository safely.
- Friday At Five To Five: DevOps And DevSecOps (2 labs): You can describe DevOps and DevSecOps and how GitOps puts them into practice, catch problems in a pull request with a real schema gate and policy as code, list what GitOps gives a security team, and explain why admission control backs up pre-merge checks.
- What Does CI Still Do? CI, CD And Where GitOps Starts (2 labs): You can define continuous integration, continuous delivery and continuous deployment, show the CI-to-GitOps handoff as a real commit to a config repository, assign each delivery stage to CI, people or the agent, and explain image automation.
- Related Practices Sprint: One Change, Five Practices (3 labs): You can name the related practice behind each step of a real delivery path, separate configuration and infrastructure as code, CI, DevSecOps, delivery and GitOps, and answer eight related-practices questions at exam pace.
GitOps Patterns
- Always A Way Back: Rolling, Blue/Green And Canary (2 labs): You can choose between recreate, rolling update, blue/green and canary, predict a rollout from maxSurge and maxUnavailable, roll back with one command and size a canary by pod count.
- Thursday, With A Way Back: Promotion, Deploy And Release (2 labs): You can compare folder, branch and repository per environment, promote a version with a real pull request-style merge and roll it back with a revert, separate deploy from release with flags kept in the state store, and treat the rollout strategy as desired state.
- Friday, Four Fifty: Progressive Delivery (2 labs): You can explain progressive delivery, read a canary and a blue-green rollout step by step, predict where an analysis aborts a release, and put the state store right after an abort with a commit.
- Three Minutes Of Waiting: Pull Versus Event-Driven (2 labs): You can compare polling and event-driven reconciliation for latency, load, network reach and reliability, explain why a webhook does not break the pull principle, and choose a setup with a fallback poll.
- Three Regions By Spring: GitOps Architecture (2 labs): You can compare in-cluster and external hub-and-spoke reconcilers for credentials, failure and operations, separate config from application code, and choose between one config repository and several.
- Patterns Sprint: Eight Needs, One Pattern Each (3 labs): You can name the GitOps pattern behind a stated need across release, progressive delivery, pull and event-driven reconciliation and architecture, and answer eight patterns questions at exam pace.
Tooling
- Three Teams, Three Formats: Manifests And Packaging (3 labs): You can compare plain manifests, Kustomize overlays and Helm charts, build an overlay with kubectl kustomize, read a chart rendered with Helm 4.3.0, and explain how Argo CD and Flux each use Helm.
- A Bucket Nobody Wrote Down: State Stores Beyond Git (2 labs): You can judge any state store against the glossary's criteria, compare Git, OCI registries and buckets on versioning and immutability, and declare and validate Flux GitRepository, OCIRepository and Bucket sources.
- Sync: Manual Or Automated, Prune And Self-Heal (3 labs): You can read an application's drift resource by resource, choose manual or automated sync with prune and selfHeal, predict what automated sync does on a new commit, a live edit or a failed sync, and pick the sync options a team needs.
- A Bake-Off With One Rule: Argo CD And Flux (2 labs): You can describe how Argo CD and Flux are built, declare the same application in each, explain why Flux has no self-heal field while prune is required, and compare the two for a team's needs.
- A Rollback Nobody Heard: Notifications, Observability And CI (2 labs): You can declare notifications from an agent to people and tools, read sync and health as the two observability signals, derive delivery metrics from commits and agent events, and place CI before and after the agent.
- Tooling Sprint: The CTO's Shopping List (3 labs): You can match formats, state stores, reconciliation engines and interoperability features to a stated need, avoid the product-name traps, and answer eight tooling questions at exam pace.
Mock And Review
- Forty-Six Of Sixty: The Mock And What It Tells You (2 labs): You can take a timed mock under exam rules, turn its results into a revision order by domain weight, reduce each miss to a rule and the lesson behind it, and decide when a score is ready to book.
- The Evening Before: Final Review (3 labs): You can state the four OpenGitOps principles word for word, chain the glossary terms through one reconciler run, place each related practice, pattern and tool in one line, and sit a final timed rehearsal.