Confluent · CCDAK
Validates proficiency in building applications with Apache Kafka, covering Kafka fundamentals, application development using producer and consumer APIs, Kafka Streams, Kafka Connect, testing, and observability.
Practice Questions
624
≈ 10 practice exams
Duration
90 minutes
Passing Score
70%
Difficulty
AssociateLast Updated
Sep 2026
The CCDAK is not a trivia test on Kafka terminology — Confluent writes it as a scenario exam that checks whether you understand the tradeoffs real Kafka code makes in production, and community exam reports keep surfacing the same handful of traps. Setting acks=all on a producer does nothing for durability on its own; without a matching min.insync.replicas on the topic, a full ISR still isn't required, and the exam expects you to catch that. Kafka guarantees ordering only within a partition, never across a topic, which sinks anyone who assumes global ordering. Consumer groups with more consumers than partitions leave the extras permanently idle — a classic 'why is my consumer doing nothing' scenario question. And exactly-once semantics apply strictly to Kafka's own producer-transaction-consumer loop; a side effect written to an external database sits outside that guarantee and needs its own idempotency handling. These traps cluster in the two heaviest domains, Application Development at 28% and Kafka Fundamentals at 23%, which together are over half the exam. This 624-question bank is weighted to match: Connect at 15%, Observability at 13%, Streams at 12%, and Testing at 8% each get proportional coverage, with Streams questions built around windowing and stream-table duality rather than padded recall items.
Confluent doesn't publish an exact question count or numeric cut score for the CCDAK. It's a 90-minute, fully remote, online-proctored exam priced at $150 USD, and candidate reports over the past two years converge on roughly 55 to 70 questions, most commonly cited around 60. Confluent's own certification page describes the question types as multiple-choice, matching, and list-order (build-list) items, so expect at least one question where you drag steps of a producer send or a consumer poll loop into the correct sequence, not just pick from four options. Results post immediately as pass or fail, with no percentage shown. Confluent explicitly scopes several adjacent topics out of the exam: ksqlDB, Confluent for Kubernetes, role-based access control, connector-specific plugin internals, and general Kafka cluster administration — time spent studying broker tuning or RBAC policy is time not spent on the client-code and configuration questions that actually appear. The certification stays valid for two years; recertifying means passing whatever version of the exam is current at that time, since Confluent has no continuing-education renewal track. A failed attempt can be retaken after a mandatory 7-day wait, and you'll need to purchase a new voucher.
There's no formal prerequisite or required training course — Confluent's guide simply assumes fluency in Java, Python, or C#, plus 6 to 12 months of hands-on time writing and running Kafka applications, not just reading about them. That hands-on bar matters more than it sounds: candidates who've only worked through tutorials report getting caught by questions on schema evolution compatibility modes (BACKWARD, FORWARD, FULL) and Schema Registry subject naming strategies that only click once you've actually changed a schema on a running topic. Kafka Streams pulls a disproportionate share of study anxiety despite being just 12% of the exam — the fix is treating processing.guarantee (at_least_once vs. exactly_once_v2), stateful topology joins, and windowing types as a focused afternoon of practice rather than the centerpiece of your prep. CCDAK carries real market weight: Kafka-skilled developers in the US average roughly $127,000 to $140,000 depending on experience level, and the credential is issued directly by the company Kafka's original creators founded, which gives it more hiring-manager credibility than third-party Kafka credentials. Start with the 30 free questions, then work through the full 624-question bank until your accuracy holds steady across all six domains — especially the two, Development and Fundamentals, that decide the outcome.
The Confluent Certified Developer for Apache Kafka (CCDAK) is a vendor-issued, scenario-based exam from Confluent — the company founded by Kafka's original creators — that checks whether a developer can build and operate Kafka applications correctly under realistic constraints, not just recite architecture terms. Rather than testing definitions in isolation, the exam leans on configuration and behavior scenarios: what happens when acks=all is set without a matching min.insync.replicas, why a consumer group with more members than partitions leaves consumers idle, and where the boundary of Kafka's exactly-once guarantee actually sits. That scenario style is what candidates most often flag as the exam's real difficulty, more than the raw topic list.
The exam spans six domains — Application Development, Kafka Fundamentals, Kafka Connect, Application Observability, Kafka Streams, and Application Testing — but Confluent explicitly excludes several adjacent platform topics: ksqlDB, Confluent for Kubernetes, role-based access control, connector-plugin internals, and general cluster administration. Those areas belong to Confluent's separate administrator/operator certification track, which keeps the CCDAK narrowly scoped to what an application developer, not a platform operator, needs to know.
CCDAK targets software developers, backend engineers, and solutions architects who write and operate Kafka-based applications in production — producing to and consuming from topics, building Kafka Streams topologies, or wiring up Kafka Connect pipelines as part of their day-to-day work. Confluent's own guidance points to roughly 6-12 months of hands-on Kafka experience as the realistic floor; the exam's scenario questions are written assuming you've actually debugged a rebalance storm or a schema compatibility break, not just read about one.
It suits engineers building event-driven microservices or real-time data pipelines at organizations running Kafka at meaningful scale — finance, ad tech, logistics, and streaming media are common employers of CCDAK holders, following the pattern set by large-scale public Kafka deployments at companies like LinkedIn (where Kafka originated), Netflix, and Uber. It's a weaker fit for platform/SRE-track engineers whose job is cluster operations rather than application code — that audience is better served by Confluent's operator-focused certification, since RBAC and cluster administration are explicitly out of scope here.
Confluent sets no formal prerequisite and requires no prior course or certification for the CCDAK. The exam guide instead assumes practical fluency in a JVM language or another supported client language (Java, Python, or C#) and comfort writing producer and consumer code against the Kafka client libraries, not just conceptual familiarity with the platform.
The unofficial but consistently cited baseline is 6-12 months of hands-on Kafka or Confluent Platform experience. Candidates should be comfortable with topics, partitions, replication, and consumer group coordination, plus Confluent Schema Registry's subject naming strategies (TopicNameStrategy, RecordNameStrategy, TopicRecordNameStrategy) and compatibility modes (BACKWARD, FORWARD, FULL, NONE) before sitting the exam — these appear in scenario form rather than as simple recall.
The CCDAK is a 90-minute, fully remote, online-proctored exam priced at $150 USD. Confluent does not publish an exact question count or numeric passing score; community reports over the past two years converge on roughly 55-70 questions, most commonly cited around 60, and results are shown as pass or fail immediately on completion with no percentage breakdown.
Confluent's own certification page lists the question formats as multiple-choice, matching, and list-order (build-list) items — so beyond picking a single or multiple correct answers, expect at least one question that requires ordering the correct sequence of steps in a producer send or consumer poll workflow. The certification is valid for two years; recertifying requires retaking whatever version of the exam is current at that time, and a failed attempt carries a mandatory 7-day wait before a new voucher can be purchased and the exam retaken.
CCDAK signals verified, hands-on Kafka competence in a market where event streaming has become standard infrastructure at companies running mission-critical real-time systems — LinkedIn (where Kafka originated), Netflix, and Uber among the large-scale public examples, alongside a long tail of finance, logistics, and ad-tech employers running Kafka in production. PayScale data puts mid-career US developers with Apache Kafka skills at an average of roughly $140,000 (25th-75th percentile range of $83,000-$164,000), separate market tracking puts CCDAK-linked roles at a $140,000+ salary floor, and UK Kafka developer postings clustered around a £100,000 median in the most recently tracked period.
Because Confluent — the company founded by Kafka's original creators — issues the credential directly, it carries more weight with technical hiring managers than third-party Kafka courses or badges. It's most useful as a hiring-stage differentiator and salary-negotiation anchor for backend/streaming-focused developer roles, and as a stepping stone toward Confluent's operator-track certification for engineers moving into platform or SRE work. The two-year validity window means the credential needs periodic renewal to stay current with the platform.
5 sample questions with answers and explanations. The full bank has 624 questions, enough for 10 full-length practice exams.
Preview — answers shown1. A Kafka Streams application is configured with processing.guarantee=exactly_once_v2. What is the default commit.interval.ms for this configuration? (Select one!)
Explanation
When processing.guarantee is set to exactly_once_v2, Kafka Streams automatically sets commit.interval.ms to 100 milliseconds to ensure frequent transaction commits and low latency. This contrasts with the at_least_once guarantee which defaults to 30000 milliseconds (30 seconds). The lower commit interval for exactly-once processing reduces the window of potential reprocessing after failures while maintaining transactional semantics. The exactly_once_v2 guarantee also automatically enables read_committed isolation level and idempotent producers.
2. A Kafka Streams application performs a hopping window aggregation with window size of 10 minutes and hop size of 5 minutes. An event with timestamp 10:00:00 arrives. How many windows will contain this event? (Select one!)
Explanation
Hopping windows with size 10 minutes and hop 5 minutes create overlapping windows. Windows start at [09:55-10:05], [10:00-10:10], [10:05-10:15], etc. An event at timestamp 10:00:00 falls into two windows: [09:55-10:05] where it's in the last 5 minutes, and [10:00-10:10] where it's at the start. Hopping windows overlap by (window size - hop size), which is 5 minutes in this case. Each event appears in (window size / hop size) = 10/5 = 2 windows. Grace period affects how long windows remain open for late-arriving data but doesn't change how many windows an on-time event belongs to. If hop size equaled window size (tumbling window), events would belong to exactly 1 window.
3. A development team configures a producer with enable.idempotence=true, acks=all, and retries=10. They want to maximize throughput by allowing multiple in-flight requests. What is the maximum value they can set for max.in.flight.requests.per.connection while maintaining ordering guarantees? (Select one!)
Explanation
With idempotent producers, ordering is maintained with max.in.flight.requests.per.connection up to 5. The producer assigns sequence numbers to messages, and the broker can reorder them correctly even with multiple in-flight requests. Setting it to 1 maintains ordering but reduces throughput unnecessarily. Values above 5 are not allowed with idempotence enabled. Without idempotence, max.in.flight.requests.per.connection must be 1 to guarantee ordering.
4. A Kafka Streams application processes IoT sensor data and performs windowed aggregations using tumbling time windows of 5 minutes. The application is configured with processing.guarantee=exactly_once_v2. What is the default commit interval for this configuration? (Select one!)
Explanation
When processing.guarantee is set to exactly_once_v2, Kafka Streams automatically sets the commit.interval.ms to 100 milliseconds to minimize latency for committing transactions. This frequent committing ensures that exactly-once processing semantics are maintained with minimal delay. The default commit interval for at_least_once processing guarantee is 30 seconds. The 5-second and 1-second values are not default commit intervals for any processing guarantee configuration.
5. A Kafka Streams application performs a 10-minute tumbling window aggregation. The application is configured with processing.guarantee=exactly_once_v2. How frequently are state store updates committed to changelog topics by default? (Select one!)
Explanation
With exactly_once_v2 processing guarantee, Kafka Streams commits state store changes every 100 milliseconds by default (commit.interval.ms=100). This frequent committing ensures low recovery time while maintaining exactly-once semantics. The at_least_once guarantee uses a 30-second commit interval. State stores commit independently of window boundaries, not only when windows close. The 5-second interval is not a default for any processing guarantee.
Yes, but proportionally little — Kafka Streams is only 12% of the exam. You need the core concepts: DSL vs. Processor API, KStream/KTable duality, windowing types (tumbling, hopping, sliding, session), and the processing.guarantee config that switches between at_least_once and exactly_once_v2. Deep production-scale Streams tuning isn't tested.
There's no live coding lab. It's a 90-minute proctored exam using multiple-choice, matching, and list-order (build-list) questions, per Confluent's own certification page. But the questions are scenario-based and assume you've actually run Kafka code, not just read about it — several trip up candidates who only studied in theory.
Confluent doesn't publish an official count. Community reports over the past two years range from about 55 to 70 questions in the 90-minute sitting, with 60 the most commonly cited figure.
Confluent doesn't publish a cut score. You get a pass or fail result on screen immediately after finishing, with no percentage breakdown shown.
$150 USD per attempt. A failed attempt requires a mandatory 7-day wait and a new voucher purchase before you can retake it.
Six domains: Application Development 28%, Kafka Fundamentals 23%, Kafka Connect 15%, Application Observability 13%, Kafka Streams 12%, and Application Testing 8%. Development and Fundamentals alone make up more than half the exam.
Confluent's exam guide excludes ksqlDB, Confluent for Kubernetes, role-based access control (RBAC), connector-specific plugin internals, and general Kafka cluster administration — those live on Confluent's operator-track certifications instead.
No formal prerequisite or required course. Confluent's guide assumes fluency in Java, Python, or C# plus roughly 6-12 months of hands-on Kafka application development experience.
Two years from your pass date. Recertifying means passing the current version of the exam again — Confluent has no PDU or continuing-education renewal path for this credential.
$17.99
One-time access to this exam