# cncf/curriculum: the fifteen exam syllabuses behind CNCF certification

> A document repository, not code: one PDF and one source directory per CNCF certification exam, versioned to the Kubernetes release so training providers and candidates study the same list of objectives.

**cncf/curriculum** — 📚Open Source Curriculum for CNCF Certification Courses

- Repository: https://github.com/cncf/curriculum
- Website: https://www.cncf.io/certification/training/
- Stars: 6,844 · Forks: 2,134
- Language: Unknown
- License: not declared
- Published: 2026-10-06 · Updated: 2026-10-06 · Language: en
- Canonical page: https://hysenlabs.com/projects/cncf-curriculum

## One document per exam, fifteen exams in total

The repository description is one line: Open Source Curriculum for CNCF Certification Courses. Everything else in the tree follows from that. There is no code to build and no package to install; there is a set of documents, and the tree makes the structure obvious at a glance.

At the top level sit fifteen PDFs named after their exams: `CAPA_Curriculum.pdf`, `CBA_Curriculum.pdf`, `CCA_Curriculum.pdf`, `CGOA_Curriculum.pdf`, `CKAD_Curriculum_v1.35.pdf`, `CKA_Curriculum_v1.35.pdf`, `CKS_Curriculum v1.34.pdf`, `CNPA_Curriculum.pdf`, `CNPE_Curriculum.pdf`, `ICA_Curriculum.pdf`, `KCA_Curriculum.pdf`, `KCNA_Curriculum.pdf`, `KCSA Curriculum.pdf`, `OTCA_Curriculum.pdf` and `PCA_Curriculum.pdf`. Alongside them are fifteen lowercase directories matching the exam acronyms, plus `old-versions/` and a `README.md`.

Those PDFs are the shipped artifact and the directories are their sources, which is why every exam can be revised without touching the others. The directory-per-exam layout is the right choice for a body of documents that grows by accretion, since a correction to the Kubernetes security specialist objectives should not have to be reconciled against a correction to the Prometheus objectives.

One detail worth knowing if you script against this tree: the naming is not perfectly uniform. Two files use a space rather than an underscore, `CKS_Curriculum v1.34.pdf` and `KCSA Curriculum.pdf`, and only the CKA and CKAD files carry a version suffix. Anything that globs these files by pattern has to cope with that.

## What the version number actually tracks

The README explains versioning in one sentence and it is the sentence most people skim: the document major and minor version, the 1 and 8 in 1.8.0, match the version of Kubernetes, and the patch version, the 0 in 1.8.0, represents any iterations in the documentation for that version of Kubernetes.

So the numbers are not a document revision count. A curriculum sitting at 1.35 is describing Kubernetes 1.35, and a patch bump such as 1.35.1 means the objectives were edited for that same Kubernetes release, typically because a domain changed or an error was fixed. Reading a stale-looking patch number as an old document would be a mistake.

The filenames confirm the scheme is applied selectively and honestly. The CKA and CKAD PDFs carry `v1.35` in their names while most others carry no version at all, and the CKS file shows `v1.34`, lagging the other two by a release. That is a useful signal: the core Kubernetes exams are updated with the Kubernetes release cadence, and the vendor-adjacent and platform exams move on their own schedules.

Historical documents are not deleted. The README links an `old-versions/` directory where previous releases remain available, which is what makes the repository useful to someone who took an exam against an older release and wants the objectives they were actually tested on.

## The fifteen credentials and how they group

The README lists the exams the curriculum covers, and the list has grown well past the original Kubernetes administrator and developer pair. The core trio is Certified Kubernetes Administrator (CKA), Certified Kubernetes Application Developer (CKAD) and Certified Kubernetes Security Specialist (CKS). The Kubernetes and Cloud Native Associate (KCNA) and Kubernetes and Cloud Native Security Associate (KCSA) sit alongside them as the broader entry-level pair.

Platform engineering has its own two-rung ladder, the Certified Cloud Native Platform Engineering Associate (CNPA) and the Certified Cloud Native Platform Engineer (CNPE), and this is the most distinctive structural feature of the list. An associate and an engineer credential on the same subject is a different shape from the CKA/CKAD/CKS trio, where the three are different jobs rather than two levels of one job.

The rest are ecosystem-specific, one credential per technology: Certified GitOps Associate (CGOA), Certified Argo Project Associate (CAPA), Certified Backstage Associate (CBA), Cilium Certified Associate (CCA), Istio Certified Associate (ICA), Kyverno Certified Associate (KCA), OpenTelemetry Certified Associate (OTCA) and Prometheus Certified Associate (PCA).

That breadth is the strategic point of the repository. In 2026 the cloud native job involves a platform layer built from several of these tools, and a single vendor-neutral body of objectives per tool is easier to point a hiring manager at than fifteen overlapping vendor courses.

## What the repository deliberately leaves out

There is no question bank here, no sample exam, no lab environment and no study guide. There is a list of what you are expected to know. That boundary is stated in the README's last substantive paragraph, which is about training companies rather than candidates: CNCF encourages training companies to align their offerings to cover the contents of the curriculum, and training partners can purchase coupons for the CKA exam at a wholesale price to offer at the end of their training.

That paragraph is the clearest statement of the relationship between the curriculum and the training ecosystem. The curriculum defines the target, the training market provides the instruction, and the exam measures against the target. CNCF's role here is to keep the target public and current rather than to sell a course.

Two practical consequences follow. First, because there is no sample material in the repository, the only thing you can prepare against is the objective list itself, which means precision in what you read matters more than volume. Second, the wholesale coupon arrangement for the CKA is a strong hint about where the volume is: of the fifteen credentials, the administrator exam is the one with a training pipeline behind it.

Corrections are handled in the simplest way available: the README asks readers who spot an error to open an issue. There are 27 open issues on the repository at present, which for a document set this size is a reasonable queue.

## Licensing, language and who this is for

The README states the curriculum is available under the CC-BY 4.0+ License, linking to the Creative Commons terms. That is a deliberate and sensible choice for the subject matter, since a Creative Commons Attribution licence lets a training company, a university or an employer reuse and adapt the objective lists with attribution, which is exactly what the alignment paragraph encourages. Anyone republishing the objectives owes attribution back to CNCF.

Two repository metadata fields are empty even though the content answers the question. There is no `language` set, which is reasonable for a document set but makes the repository look unclassified in search. There is also no `LICENSE` file in the tree, so the licence exists only as a statement in the README. For a repository whose entire value is that its contents can be reused under a known licence, having that licence in a file rather than a paragraph is the more durable arrangement.

The homepage field points at the CNCF training and certification page rather than at a document, which tells you where the authoritative current version is meant to be found. The single topic tag is `cncf`, which is doing very little work in search.

As for who this is for, three groups are named or implied: candidates preparing for an exam, training companies aligning a course, and employers or hiring managers looking for a vendor-neutral statement of what a credential covers.

## Repository scale and how to use it

The repository has 6,681 stars and 2,104 forks, a fork count around a third of the star count. That ratio is unusual for code and unremarkable here, because the natural reason to fork this repository is to keep a local copy of the current objectives, or to propose an edit to one exam's curriculum without going through an issue.

It is not archived, and the last push was on 2026-06-29, so the documents are being maintained on a Kubernetes release cadence rather than abandoned. The default branch is `master`. The tree also contains a `.gitignore` and nothing else of a build nature, which is a reminder that there is nothing to compile: the PDFs at the root are the deliverable and the directories below them are the editable sources.

The practical way to use all of this is unglamorous. Identify the exam by acronym, open the matching PDF at the root, and check the version in the filename or inside the document against the Kubernetes release you will actually be examined on. If you are preparing for a vendor-adjacent credential such as CCA, ICA, KCA, OTCA or PCA, assume the version suffix is absent and that the currency question is answered by the exam's own release notes rather than by this repository.

And if the document is wrong, the README's instruction is the whole process: open an issue.

## Conclusion

The cncf/curriculum repository is worth knowing about for a simple reason: it removes one variable from exam preparation. Every CNCF certification has a published list of objectives, and this repository is where that list lives, versioned against the Kubernetes release it describes. The versioning scheme is the part to understand first, because the numbers are not a document revision count in the usual sense: major and minor track Kubernetes itself, so 1.35 means Kubernetes 1.35, and only the patch digit counts curriculum edits. The exams themselves now span fifteen credentials, from the Kubernetes core three through platform engineering, GitOps, Backstage, Argo, Cilium, Istio, Kyverno, OpenTelemetry and Prometheus, and the per-exam directories in the tree mean each one can be corrected on its own schedule. What the repository does not contain is any question bank, sample lab environment or study guide, and it explicitly encourages training companies to align their offerings to it rather than providing them. Start with the PDF for the exam you are taking, check the version against the Kubernetes release you will be tested on, and open an issue if the document has an error.

## FAQ

### What does the curriculum version number mean?

Major and minor match the Kubernetes version, so 1.35 means Kubernetes 1.35. Only the patch digit counts iterations of the documentation itself, meaning a curriculum edit for that same Kubernetes release rather than a new Kubernetes release.

### Where do I find the syllabus for a specific CNCF exam?

Each exam has its own PDF at the repository root, named for the acronym, such as `CKA_Curriculum_v1.35.pdf` or `PCA_Curriculum.pdf`, plus a lowercase directory of the same name holding the source. Previous releases stay available in `old-versions/`.

### Can I reuse the CNCF curriculum in my own training material?

Yes. The README states the curriculum is available under the CC-BY 4.0+ License, so reuse and adaptation are allowed with attribution. CNCF also encourages training companies to align their offerings to cover the curriculum contents.

## Sources

- [cncf/curriculum on GitHub](https://github.com/cncf/curriculum)
- [Issues](https://github.com/cncf/curriculum/issues)
- [Project website](https://www.cncf.io/certification/training/)
- [README](https://github.com/cncf/curriculum/blob/master/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/cncf-curriculum