CKA vs CKAD: cost, duration, and which one to take first

The CKA and the CKAD each cost $445, each run two hours at a command line against a live cluster, and each need 66% to pass. The difference is the job they test: the CKA is the operator's exam, the CKAD is the developer's. Take the one that matches the work you want.

That is the short version. The rest of this is the reasoning behind it, and what the two exams are like to sit, which is the part most comparison pages leave out.

The numbers, side by side

Both figures below are from the Linux Foundation's own pages, checked in September 2026, and the CKA and CKAD pages on this site carry the current values if anything has moved since.

The exam-only price is $445 for either. The listing includes a second attempt, so a first failure does not cost you another $445. Bundles that add a course or an annual training subscription are priced above that, and whether they are worth it depends entirely on whether you would buy the course anyway.

The duration is two hours for both. That sounds generous until you are twenty minutes in and have solved two tasks.

The pass mark is 66% for both, from the candidate FAQ. Scoring is automatic and the score report arrives by email, normally within a day.

The certification is valid for two years, and renewing means passing the current exam again, not paying a fee.

Both are currently based on Kubernetes v1.35, and the version matters, because the exam environment is the version on the page, not the one on your laptop.

What the two exams test

The CKA is about running clusters. Its five domains, with their weights as published, are troubleshooting at 30%, cluster architecture, installation and configuration at 25%, services and networking at 20%, workloads and scheduling at 15%, and storage at 10%. Nearly a third of the marks are for fixing things that are broken: a node that will not join, a control plane component that has stopped, a service that resolves to nothing. The rest is building and configuring the cluster itself.

The CKAD is about running applications on a cluster someone else operates. Its domains are application environment, configuration and security at 25%, application design and build at 20%, application deployment at 20%, services and networking at 20%, and observability and maintenance at 15%. The tasks are to get a workload defined, configured, deployed, exposed, and observable, quickly and correctly. Installing a cluster never comes up.

Two of the domains overlap by name and largely by content: services and networking, and the parts of workloads and configuration that both exams touch. Someone who has passed one will find perhaps a third of the other familiar. The rest is genuinely different work.

Which one fits your role

Which certification is harder or more respected is the wrong question. The useful one is what you will be asked to do on a Tuesday.

If the job title has platform, infrastructure, site reliability, DevOps, or cloud engineer in it, and the postings mention cluster upgrades, node management, or on-call for the platform, that is CKA territory. The exam rehearses the exact situations those roles get paged for.

If the job is a software developer, backend engineer, or data engineer role where Kubernetes is the thing your code deploys onto, the CKAD matches. You need to write manifests, understand how configuration and secrets reach a container, debug a pod that will not start, and expose a service. You do not need to know how kubeadm bootstraps a control plane, and the CKAD will not ask you.

If you are moving into Kubernetes from outside tech infrastructure altogether, look at the postings for the specific role you are aiming at before choosing. The skills page for Kubernetes shows which roles ask for it and how often. A certification that matches the role's actual tasks is evidence; one that does not is a line on a CV that a good interviewer will probe.

What it is like to sit one

The format is the part people underestimate. There is no multiple choice. You get a browser-based terminal, a set of tasks, and a clock. Each task names a cluster context to switch into and something to make true: create this, fix that, make this service reachable from that pod. Marking is automated against the resulting state of the cluster, so partial work that leaves the cluster in the right state scores, and a beautiful manifest that was never applied scores nothing.

A realistic ninety minutes goes like this. The first two tasks are easy and you finish them in ten minutes, which feels good. The third asks you to fix a broken node and the obvious cause is not the cause; fifteen minutes disappear. You skip it, flag it, and move on, which is the single most important exam habit. Tasks six through nine are routine. Task ten involves a networking policy and you spend too long reading documentation you had told yourself you knew. You come back to the flagged task with twelve minutes left, notice a stopped service you missed the first time, and fix it in three. The clock runs out while you are checking your work.

That rhythm is why practice in a real terminal matters more than any amount of reading. The Linux Foundation includes access to an exam simulator with the booking, and the honest reason to use it is not the content, which you may know, but the clock and the tab-switching.

Where preparation goes wrong

The most common mistake is reading instead of typing. Kubernetes has excellent documentation and people spend weeks in it, then sit the exam and discover that knowing what a Deployment is and writing one from memory under time pressure are different skills.

The second is preparing for the wrong exam. A developer who sits the CKA because it sounds more senior will spend two hours on cluster installation questions that have nothing to do with their job and will not come up in their interviews either.

Ignoring the version catches people too. The published domains move between versions, and so does what the exam environment has installed. Prepare against the version on the certification page, which for both exams is currently v1.35.

And the certificate is evidence that you can do the tasks the exam covers, which hiring managers weigh accordingly. After two hours in a terminal it is tempting to treat it as the finish line, and that is the wrong read. The judgement the role needs is a separate thing, which is why the roles that ask for the certificate also ask for projects or experience alongside it.

Who this touches beyond infrastructure teams

Kubernetes has spread past the platform team. Data engineers deploy pipelines onto it. Machine learning engineers serve models from it. Analysts in larger companies run scheduled jobs on it without ever calling themselves engineers. For those people the CKAD is often the more useful of the two, because it tests exactly the slice of Kubernetes they touch and skips the slice they never will.

For someone changing careers into any of those roles, the certification is a way to turn learning into something an employer can inspect. It should sit next to a project that uses the same skills, not instead of one.

Where do your skills stand? Run the free career check and see whether the roles you are aiming at ask for Kubernetes, and whether it is the CKA's operator skills or the CKAD's developer skills they want.

A short decision rule

Runs clusters, or wants to: CKA. Ships code onto clusters: CKAD. Unsure: pick the role first, then the exam, because the exam is a proxy for the role and the role is what pays. Both cost the same, take the same two hours, and need the same 66%, so the price of choosing well is only the time you spend preparing for the right one.