Exampractice
DevOps & Linux

Kubernetes Certification Career Path

Sequence KCNA, CKA, CKAD, CKS and KCSA into a career trajectory. Which order fits developers, ops engineers and security specialists, and when to stop.

Kenji Nakamura · 10 min read
Subway-map style routes showing developer, operations and security tracks through the five CNCF Kubernetes certifications

Picture two engineers who both decide, this year, to "get certified in Kubernetes". The first is a backend developer who deploys services to a cluster someone else runs. The second is a sysadmin whose company is moving workloads off virtual machines. If they follow the same certification order, at least one of them is wasting months — because the Cloud Native Computing Foundation (CNCF) ladder is not a single staircase. It is a small map with branching routes, and the right path depends on the role you are walking towards, not on which exam is most famous.

This guide sequences all five CNCF Kubernetes certifications — Kubernetes and Cloud Native Associate (KCNA), Kubernetes and Cloud Native Security Associate (KCSA), Certified Kubernetes Administrator (CKA), Certified Kubernetes Application Developer (CKAD) and Certified Kubernetes Security Specialist (CKS) — into career trajectories tied to job roles and seniority. It is deliberately not a per-exam explainer; for what each exam contains, the full map of Kubernetes certifications and the individual exam guides go deep. And it is not a pay piece: earning figures live in the Kubernetes certification salary guide.

The ladder in one view

All five certifications come from the CNCF in partnership with the Linux Foundation, and all are valid for two years (for exams passed since 1 April 2024), renewed by retaking the current exam. They split cleanly into two tiers:

  • Associate tier (multiple-choice, 90 minutes, $250 exam-only as of 2026): KCNA and KCSA. Entry-level, no prerequisites, knowledge-based.
  • Professional tier (performance-based, 2 hours in live clusters, $445 exam-only as of 2026): CKA, CKAD and CKS. You solve real tasks at a command line under proctoring via PSI Bridge. The CKS is the only one with a prerequisite: a current CKA.

That hands-on format is the professional tier's career currency. Because CKA, CKAD and CKS require demonstrating skills in a live environment rather than recognising correct answers, they carry outsized hiring signal compared with typical multiple-choice certifications — a distinction worth understanding before you plan anything.

One structural fact shapes every route below: CKA is the only gate to CKS. Not KCSA, not CKAD. Whatever else you plan, a security destination runs through the CKA.

Step one: pick your destination role, not your first exam

Certification order falls out naturally once you name the role you want in two to three years. The realistic destinations look like this:

Destination roleCore cert(s)Supporting cert(s)Typical seniority signal
DevOps engineerCKAKCNA early, CKAD optionalMid-level
Platform engineerCKA, then CKSCKAD for developer empathyMid to senior
Backend/cloud-native developerCKADKCNA earlyMid-level
Site reliability engineer (SRE)CKACKS in regulated settingsMid to senior
DevSecOps / platform security engineerCKA + CKSKCSA as on-rampSenior
Engineering-adjacent (PM, presales, architecture-lite)KCNAKCSA if security-flavouredEntry to mid

Two clarifications the table can't carry. First, "platform engineer" and "DevOps engineer" job adverts overlap heavily; both hire on CKA. Second, the developer route genuinely can stop at CKAD — a developer who ships well on Kubernetes does not need cluster-administration credentials unless they intend to cross into platform work.

The three main routes

Route 1: the operations track (sysadmin → DevOps/platform engineer)

Sequence: (KCNA) → CKA → CKS if security-bound.

This is the classic path for anyone coming from system administration, infrastructure or general IT operations.

  1. KCNA — optional on-ramp. If you have never worked with containers or cloud-native tooling, the KCNA gives you vocabulary and a low-stakes first win. If you already run Linux systems and have touched Kubernetes at work, skip it: it is entry-level by design, and hiring managers for ops roles look for the CKA.
  2. CKA — the anchor. This is the credential the operations track is built around, covering troubleshooting, cluster architecture, networking, workloads and storage in a live environment. Mid-level DevOps and platform roles treat it as the standard Kubernetes signal.
  3. CKS — the seniority multiplier. Once your remit includes hardening, compliance or platform security, add the CKS while your CKA is current and your cluster speed is fresh. Whether and when this step pays off is a decision with its own trade-offs, unpacked in the CKA vs CKS comparison.

A realistic version: a sysadmin with four years of Linux experience skips KCNA, spends a focused stretch on CKA preparation with daily cluster labs, passes, moves into a DevOps engineer role, and returns for the CKS eighteen months later when the platform team takes on PCI-scoped workloads. That is the operations track working as intended — each exam lands just before the responsibility that justifies it.

Route 2: the developer track (backend developer → cloud-native developer)

Sequence: (KCNA) → CKAD → stop, or CKA if crossing into platform work.

The CKAD tests what developers actually do on Kubernetes: designing, building, configuring, deploying and observing applications. Despite persistent folklore, it is not "the beginner exam" — both CKAD and CKA are intermediate; KCNA is the genuine entry point.

  1. KCNA — only if containers are new to you. Developers already comfortable with Docker images and deployments lose little by going straight to CKAD.
  2. CKAD — the core credential. For a developer, this is usually the whole journey. It has no prerequisites and unlocks nothing else on the ladder — its value is direct: proof you can operate confidently in the environment your code runs in.
  3. CKA — only for lane-changers. Developers migrating towards platform, SRE or DevOps roles add the CKA later. If you are torn about which of the two to sit first, that head-to-head has its own dedicated treatment in CKAD vs CKA: which exam first — one sentence of guidance here would shortchange it.

Route 3: the security track (→ DevSecOps / platform security)

Sequence: (KCSA) → CKA → CKS.

The counterintuitive part first: the security track's mandatory middle step is an administration exam. Because CKS eligibility requires a current CKA, there is no way to specialise in Kubernetes security without first proving general cluster competence — a sensible rule, since you cannot harden what you cannot operate.

  1. KCSA — the conceptual on-ramp. Multiple-choice coverage of the Kubernetes threat model, cluster component security and compliance frameworks. Useful for building the security mental model early, and for security professionals coming into Kubernetes from outside; but remember it grants no eligibility for anything.
  2. CKA — the mandatory gate. Treat it as part of the security curriculum, not a detour: CKS tasks assume CKA-level fluency.
  3. CKS — the destination. Hands-on hardening, supply chain security, runtime monitoring and vulnerability minimisation. Paired with the CKA, it is the strongest role-specific signal on the CNCF ladder for DevSecOps and platform security positions.

Timing matters more on this route than any other. The CKA's two-year validity is also your CKS eligibility window, so plan the two exams as one campaign rather than two separate projects.

Sequencing mistakes that cost people months

  • Starting with KCNA out of caution when experience says skip it. The associate exams exist for genuine beginners and adjacent roles. An engineer already running workloads who detours through KCNA delays the credential employers actually shortlist on.
  • Taking KCSA believing it unlocks CKS. It does not. Only the CKA does. KCSA is worthwhile on its own terms, not as a gate pass.
  • Collecting CKA and CKAD simultaneously "for completeness". Their curricula overlap enough that holding both adds less signal than most people expect, unless your role genuinely straddles development and operations — or you are deliberately pursuing Kubestronaut status (below).
  • Letting the CKA expire before starting the CKS. Renewal is a full retake; an expired CKA means re-passing an administration exam before you can even book the security one.
  • Chasing certification order instead of production experience. Certifications sequence a career; they do not substitute for one. The strongest profiles alternate exam, then role application, then next exam — not three exams back-to-back into an unchanged job.
  • Planning around a discontinued credential. The Docker Certified Associate still appears on stale roadmap lists; it was discontinued after Mirantis acquired Docker Enterprise and has no successor. The CNCF ladder is the current container path.

How the ladder maps to seniority

A useful way to read the CNCF ladder is as a statement about what you can be trusted with:

  • Associate certs (KCNA, KCSA) say: I understand this ecosystem. They fit students, career changers, junior engineers and non-engineering roles that sit near Kubernetes. They rarely move the needle for someone already mid-career in infrastructure.
  • CKA or CKAD says: I can do the work unsupervised. This is the mid-level marker — the point where the certification and the job description start matching each other.
  • CKA + CKS (or a professional cert plus visible production scars) says: I can own the platform. Senior platform and DevSecOps roles cluster here. Note that seniority itself still comes from scope and judgement demonstrated at work; the certs corroborate it.

The Kubestronaut question

The CNCF recognises holders of all five Kubernetes certifications through its Kubestronaut programme. As a career strategy, completing the set makes most sense for consultants, trainers and developer-advocacy profiles, where breadth across the whole ladder is itself the product. For a single-track engineer, the marginal exam beyond your route usually returns less than deepening the route you are on — check the programme's current benefits on the CNCF's Kubestronaut page before making it a goal.

Where non-CNCF certifications fit around the ladder

A Kubernetes career rarely runs on Kubernetes credentials alone, and the strongest multi-year plans interleave the CNCF ladder with adjacent proof points rather than treating it as the whole syllabus.

Infrastructure as code. The HashiCorp Certified: Terraform Associate (exam 004 since January 2026, listed at $70.50 plus taxes) is the most common companion to the CKA on platform-engineering CVs, because provisioning the infrastructure under the cluster is half the job description. It is a one-hour multiple-choice exam — far lighter than any CNCF professional cert — which makes it an efficient add between rungs rather than a rung of its own. The lab-based Terraform Authoring and Operations Professional exists above it for engineers who make infrastructure automation their centre of gravity.

CI/CD and delivery. GitHub's certification family — GitHub Foundations (GH-900) and GitHub Actions (GH-200), delivered via Pearson VUE since July 2025 at $99 per exam in most regions — covers the pipeline side that CNCF exams touch only lightly. The Actions exam in particular pairs naturally with the CKAD for developers who own their own delivery.

Cloud-provider DevOps certs. AWS, Azure and Google Cloud each offer professional-level DevOps credentials. These make sense once your employer's platform is settled; the CNCF certs deliberately stay vendor-neutral, which is exactly why they travel better between jobs. Check current prices and formats on each provider's page — they change more often than the CNCF line-up does.

The sequencing principle: keep the CNCF ladder as your spine and slot these in where a role demands them, not pre-emptively. A CKA plus Terraform Associate plus production experience beats a shelf of unused associate certificates in nearly every platform-engineering interview.

How long does the full path take?

The Linux Foundation publishes no official study-hour figures, and honest planning starts from your existing experience rather than a universal timeline. What can be said structurally: each exam purchase includes a 12-month eligibility window, so a purchased exam sets a hard outer deadline; the professional exams reward daily short lab sessions over occasional long ones, because they are tests of speed and fluency rather than recall; and the CKA-to-CKS gap is best kept to months, not years, while both your cluster speed and your CKA validity are fresh. Most engineers should therefore think of each professional rung as a focused campaign measured in weeks-to-months of consistent practice, separated by longer stretches of applying the skills at work — and resist compressing the whole ladder into a single year unless a role change demands it.

A working plan you can adapt

A pragmatic template for the most common case — an engineer with some Kubernetes exposure aiming at platform work:

  1. Audit yourself against the CKA domains (troubleshooting, cluster architecture, networking, workloads, storage) using hands-on tasks, not reading. If you cannot yet perform basic operations quickly at a command line, schedule a KCNA-level study block first — with or without the exam.
  2. Prepare for the CKA with daily lab time, then book the exam when timed practice shows consistent passing-level performance. The week-by-week detail belongs to the dedicated CKA preparation guide; benchmark readiness with timed runs — ExamPractice's CNCF exam practice questions let you score yourself by domain and target the weak ones rather than re-reading what you already know.
  3. Apply the credential immediately — internal platform work, a role change, or ownership of a cluster migration. Six to twelve months of applied experience does more for the next rung than a third certificate would.
  4. Decide on the CKS at least six months before your CKA expires, so a yes still leaves comfortable runway and a no is a real decision rather than a default.
  5. Diarise renewals. Two-year validity with retake-only renewal means your ladder needs maintenance; a senior profile with expired certs reads worse than a shorter, current one.

Choosing your next rung

The Kubernetes certification career path is short enough to state in one breath once you know your destination: operations people anchor on the CKA and add the CKS when security enters their remit; developers anchor on the CKAD and usually stop; security-bound engineers run KCSA-optional through CKA to CKS as a single campaign; and the associate certs serve genuine newcomers, not experienced engineers hedging. Pick the destination role first, take the shortest route the prerequisites allow, and put working experience between the rungs — that combination, far more than the number of logos on your profile, is what carries a Kubernetes career upwards.

Exam facts in this guide were checked against official certification-provider pages on . Fees, exam codes and policies change — confirm on the provider’s own site before you book.

Put it into practice

Test what you have just read

Reading about an exam only takes you so far. Work through practice questions for your certification and find the gaps before exam day does.

You may also like