5 exercises — CKAD vs. CKA scope, sidecar/ambassador/adapter design patterns, ConfigMaps vs. Secrets, liveness/readiness/startup probes, and Job vs. CronJob. CKAD's application-developer vocabulary, distinct from CKA's cluster-administration focus.
Why precise CKAD vocabulary matters
Application-developer scope — building/deploying apps, not administering the cluster
Multi-container patterns — sidecar, ambassador, adapter are three distinct, testable patterns
ConfigMap vs. Secret — non-sensitive vs. sensitive configuration injection
Liveness vs. readiness vs. startup probe — restart vs. traffic-routing vs. slow-start handling
Job/CronJob vs. Deployment/DaemonSet — run-to-completion vs. continuous vs. per-node workloads
0 / 5 completed
1 / 5
CKAD and CKA share the same hands-on, terminal-based exam format and are both administered by CNCF. What is the core difference in what each exam tests, and why would a job posting specify one over the other?
Both exams share the same 100% performance-based, hands-on terminal format and 2-hour time limit administered by the Linux Foundation/CNCF, but they test genuinely different job functions. CKA is the platform/infrastructure-engineer exam (own and operate the cluster). CKAD is the application-developer exam (build and ship workloads correctly onto a cluster someone else manages).
2-hour exam, roughly 15–20 tasks, same killer.sh practice simulator as CKA
Open book — kubernetes.io documentation only, same narrow rule as CKA
Renewal every 3 years through CNCF
CKAD is not a prerequisite-gated exam — it can be taken independently of CKA, and many application developers take only CKAD without ever needing CKA
Job postings that list "CKAD preferred" rather than "CKA preferred" are signalling they want application-layer Kubernetes fluency, not cluster-operations responsibility — a distinction worth recognising when reading job requirements in English.
2 / 5
A CKAD task requires designing a Pod where a small helper container continuously ships logs from a shared volume to an external system, running alongside the main application container for its entire lifecycle. Which multi-container pod design pattern does this describe?
The sidecar pattern is a core CKAD design-pattern topic: a secondary container that runs for the entire lifetime of the pod alongside the main application container, typically sharing a volume or network namespace to extend functionality (log shipping, in this example) without modifying the main container's image.
The three multi-container patterns CKAD explicitly names, and how to tell them apart:
Sidecar — runs continuously alongside the main container, extending its behaviour (log shipping, file syncing)
Ambassador — a proxy that simplifies the main container's outbound connections to external services (e.g. handling retries or service discovery on its behalf)
Adapter — standardises or transforms the main container's output into a common format for external tools (e.g. converting custom app metrics into a Prometheus-compatible format)
Separately, an init container runs before the main container starts and must complete successfully first — it is not a "pattern" of ongoing collaboration but a sequencing mechanism, and is the most common wrong answer offered as a distractor for sidecar questions since both involve "extra containers in one pod."
3 / 5
A CKAD task asks the candidate to inject application configuration (a database URL, a feature flag) into a running container without rebuilding the container image, and to keep sensitive values like an API key separate from non-sensitive settings. Which two Kubernetes objects does this scenario require, and what is the key difference between them?
ConfigMaps and Secrets are core CKAD "Application Design and Build" domain objects, and the exam tests precise knowledge of when to use each and how to inject them (as environment variables via envFrom/valueFrom, or as mounted volumes). The critical distinction: Secrets are intended for sensitive data (though base64 encoding is not encryption — a common exam-adjacent gotcha for security awareness), while ConfigMaps are for ordinary, non-sensitive configuration.
Related CKAD vocabulary on the same topic:
envFrom — inject an entire ConfigMap/Secret's keys as environment variables at once
volumeMounts with a ConfigMap/Secret volume — expose configuration as files inside the container instead of environment variables, useful when an app expects a config file rather than env vars
Immutable ConfigMaps/Secrets — a field that prevents accidental updates, tested as a best-practice option
This decoupling of configuration from the image is a fundamental "twelve-factor app" principle CKAD assumes candidates already understand conceptually, then tests the exact Kubernetes mechanics of implementing it.
4 / 5
A CKAD task configures a container so that Kubernetes automatically restarts it if it becomes unresponsive, but only routes traffic to it once it has finished its startup work and is actually able to serve requests. These two checks are called the _____ probe and the _____ probe, respectively.
The liveness probe answers "is this container still alive/healthy, or should Kubernetes restart it?" The readiness probe answers "is this container ready to receive traffic right now?" — a container can be alive (liveness passes) but not yet ready (still loading a cache, warming up a connection pool), in which case the Service should not route traffic to it yet even though it shouldn't be restarted.
The full probe vocabulary CKAD tests (a dedicated exam domain, "Application Observability and Maintenance"):
Liveness probe — failing repeatedly triggers a container restart
Readiness probe — failing removes the pod from a Service's endpoints (no traffic routed), without restarting anything
Startup probe — used for slow-starting containers, delays liveness/readiness checks until the app has genuinely finished initialising, preventing a slow-but-healthy app from being killed prematurely by an impatient liveness probe
Exam scenarios frequently describe symptoms ("the pod keeps restarting even though the app eventually starts fine") that require recognising a missing startup probe as the root cause — precise vocabulary distinguishes "restart" (liveness) from "removed from load balancing" (readiness) symptoms.
5 / 5
A CKAD task requires a job that runs a data-cleanup script every night at 2 AM, retrying up to 3 times if it fails, and a separate one-off script that must run exactly once during a deployment to migrate a database schema. Which two Kubernetes objects match each requirement?
A Job runs one or more pods to completion — ideal for a one-off task like a database migration — and can be configured with completions and parallelism for more complex batch patterns. A CronJob wraps a Job with a schedule (standard cron syntax, e.g. 0 2 * * * for 2 AM daily), automatically creating a new Job run at each scheduled time.
Precise CKAD vocabulary around these workload types:
backoffLimit — the number of retries a Job attempts before being marked failed
restartPolicy — for Jobs/CronJobs, must be Never or OnFailure (never Always, which is only valid for long-running workloads like Deployments)
Deployment — for long-running, stateless, continuously-serving workloads (not "run once and stop")
DaemonSet — ensures exactly one copy of a pod runs on every (or selected) node, used for node-level agents like log collectors, not scheduled batch work
Distinguishing "runs to completion" (Job/CronJob) from "runs continuously" (Deployment) from "runs once per node" (DaemonSet) is a foundational CKAD vocabulary distinction that recurs across multiple exam tasks.
What will I practice in "CKAD (Certified Kubernetes Application Developer) Vocabulary — Exam Language"?
This is a Certification Prep exercise set. It walks through 5 scenario-based multiple-choice questions built around real usage of Certification Prep terminology that IT professionals encounter on the job.
Is this exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is free to complete with no account, sign-up, or paywall.
How many questions are in this exercise?
This set contains 5 questions. Each one shows immediate feedback and a detailed explanation after you answer, so you learn the correct usage right away rather than waiting for a final score.
Do I need prior experience to complete this exercise?
No prior experience is required. Each question includes a full explanation covering the reasoning behind the correct answer, so the exercise itself teaches the Certification Prep vocabulary as you go.
Can I retry the exercise if I get questions wrong?
Yes — use the "Try again" button on the results screen to reset your answers and go through all the questions again. There is no limit on attempts.
Is my progress saved?
Your answers and score for the current session are tracked in the browser as you go. No account or login is needed, and there is nothing to install.
What if I don't understand a term used in a question?
Read the explanation shown after you answer each question — it breaks down the correct term in plain English with a real-world example. You can also check the site Glossary for quick definitions.
How is this different from reading a blog article on the topic?
Exercises like this one are interactive drills that test and reinforce specific vocabulary through multiple-choice questions, while blog articles explain concepts in prose. Practising here after reading builds active recall, not just passive recognition.
Where can I find more Certification Prep exercises?
See the Certification Prep exercises hub for the full set of related pages, or browse all exercise categories from the main Exercises index.
Can I use this exercise to prepare for a technical interview?
Yes — Certification Prep vocabulary comes up often in technical discussions and interviews. Pair this exercise with our dedicated Interview Preparation section for role-specific practice.