CCDAK and CCAAK course and practice exams: Confluent Apache Kafka certifications
This CCDAK and CCAAK course has 40 video lessons and 99 graded labs, and its CCDAK and CCAAK practice exams follow the official exam objectives: a 20-question sampler free with an account, the full question bank and timed mock exams with Pro.
One course, a developer track and an administrator track
Prepares you for both Confluent Kafka exams: the developer track for CCDAK (applications, Streams, Connect, testing) and the administrator track for CCAAK (configuration, security, troubleshooting, deployment).
Intermediate · 2 hours · 40 lessons · 103 labs
CCDAK exam guide
The CCDAK exam (Confluent Certified Developer for Apache Kafka, by Confluent): 90 minutes; cost: USD 150.
- Format: Multiple-choice, matching, list-order questions
- Duration: 90 minutes
- Cost: USD 150
- Valid for: 2 years
- Delivery: Online, proctored (Honorlock); requires webcam, microphone, Google Chrome
- Prerequisites: No formal prerequisites; practical Kafka development experience recommended
Exam domains and weights
- Apache Kafka Fundamentals: about 24%
- Apache Kafka Application Development: about 28%
- Apache Kafka Streams: about 12%
- Kafka Connect: about 15%
- Application Testing: about 8%
- Application Observability: about 13%
A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.
10 CCDAK sample questions with answers: free to read, no account needed.
Common questions
How long is the CCDAK exam?
The CCDAK exam lasts 90 minutes.
How much does the CCDAK exam cost?
USD 150.
Is there a free CCDAK practice test?
Yes. A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.
Source: Confluent Certification page (format, duration, renewal, retake wait) (Confluent), checked 2026-10-03.
CCAAK exam guide
The CCAAK exam (Confluent Certified Administrator for Apache Kafka, by Confluent): 90 minutes; cost: USD 150.
- Format: Multiple-choice, matching, list-order questions
- Duration: 90 minutes
- Cost: USD 150
- Valid for: 2 years
- Delivery: Online, proctored (Honorlock); requires webcam, microphone, Google Chrome
- Prerequisites: No formal prerequisites; hands-on Kafka cluster administration experience recommended
Exam domains and weights
- Apache Kafka Cluster Configuration: about 22%
- Apache Kafka Fundamentals: about 15%
- Apache Kafka Security: about 15%
- Troubleshooting: about 15%
- Deployment Architecture: about 12%
- Kafka Connect: about 11%
- Observability: about 10%
A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.
10 CCAAK sample questions with answers: free to read, no account needed.
Common questions
How long is the CCAAK exam?
The CCAAK exam lasts 90 minutes.
How much does the CCAAK exam cost?
USD 150.
Is there a free CCAAK practice test?
Yes. A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.
Source: Confluent Certification page (format, duration, renewal, retake wait) (Confluent), checked 2026-10-03.
Who it is for
Intermediate level.
For developers and Kafka administrators preparing for Confluent's CCDAK or CCAAK exam. You take the shared fundamentals, then your track, or both.
What you don't need yet:
- You don't need both exams: follow one track or both
- No Kafka cluster: labs use a simulator and real tools
- No previous Kafka certificate
- No Python: labs use the Kafka tools, YAML files and, for developers, Java
What helps:
- Comfort at a command line
- Developer track: reading short Java (two labs run a test as given)
No formal prerequisites. The courses under "Take first" cover what helps.
Take first:
- Apache Kafka & Event Streaming — Intermediate
Learning paths:
Nobody needs to know everything before they start. Each course builds on the one before, so a learning path takes you there step by step.
What this exam proves, and what it doesn't
CCDAK and CCAAK use multiple-choice, matching and list-order questions: passing shows you know Kafka for developers or administrators. They don't test hands-on skill; our graded labs use a Kafka simulator and real tools.
Exam objectives this course teaches
Confluent Certified Developer for Apache Kafka (CCDAK)
- Apache Kafka Fundamentals (about 24% of the exam): Core Kafka architecture: topics, partitions, offsets, event keys, and message ordering; Cluster internals: broker mechanics, controller, leader/follower replication, ISR (in-sync replicas); Data modeling and topic configuration: compression codecs, retention policies, compaction, and partition strategies; Command-line tools for interacting with Kafka (kafka-topics, kafka-console-producer, kafka-console-consumer, etc.)
- Apache Kafka Application Development (about 28% of the exam): Producers: write producers, configure acks, retries, idempotence, and delivery semantics (at-least-once, at-most-once, exactly-once); Consumers and consumer groups: consumer group mechanics, partition assignment strategies, rebalance protocols, and offset management; Schema management and SerDes: serialization/deserialization, schema evolution with Confluent Schema Registry (Avro, JSON Schema, Protobuf); Security for client applications: connecting to TLS-encrypted and authenticated Kafka clusters (SASL/SCRAM, SASL/PLAIN, mTLS)
- Apache Kafka Streams (about 12% of the exam): Develop stream-processing applications using the Kafka Streams API: topology, KStream, KTable, GlobalKTable; State stores: local and persistent state, interactive queries; Windowing operations: tumbling, hopping, session, and sliding windows
- Kafka Connect (about 15% of the exam): Kafka Connect concepts: source and sink connectors, workers (standalone and distributed), tasks, and transforms (SMTs); Change Data Capture (CDC): fundamentals and use cases for CDC with Kafka Connect; Configuring and deploying connectors: connector configuration, error handling, dead letter queues
- Application Testing (about 8% of the exam): Testing Kafka client applications: use of MockProducer, MockConsumer, and EmbeddedKafka; Testing Kafka Streams topologies: TopologyTestDriver for unit testing stream processing logic
- Application Observability (about 13% of the exam): Monitoring client applications: key Kafka producer and consumer metrics (record-error-rate, records-lag, fetch-latency, etc.); Logging: configure and interpret Kafka client logs for troubleshooting; Troubleshooting Kafka applications: diagnosing consumer lag, connection issues, serialization errors, and rebalance storms
Confluent Certified Administrator for Apache Kafka (CCAAK)
- Apache Kafka Cluster Configuration (about 22% of the exam): Manage and tune core broker configuration properties for high performance (e.g., num.partitions, log.retention, log.segment.bytes); Log compaction, retention policies, and storage internals; Manage partitions, replication factors, controller election, and metadata settings; Cluster scaling: adding brokers, partition reassignment, preferred leader election
- Apache Kafka Fundamentals (about 15% of the exam): Core architecture: brokers, topics, partitions, producers, consumers, and consumer groups; Internal data flows: message lifecycle, offset management, and metadata management; Administrative CLI tools: kafka-topics, kafka-configs, kafka-consumer-groups, kafka-log-dirs, etc.
- Apache Kafka Security (about 15% of the exam): Encryption: configure TLS/SSL for data in transit and at rest; Authentication: configure mTLS, SASL/PLAIN, SASL/SCRAM, SASL/GSSAPI (Kerberos); Authorization: configure and manage Access Control Lists (ACLs) with kafka-acls
- Troubleshooting (about 15% of the exam): Diagnose and resolve broker failures, network partitions, and under-replicated partitions (URPs); Resolve consumer group rebalance issues, consumer lag, and data loss scenarios; Log analysis: debug common cluster exceptions and perform recovery operations
- Deployment Architecture (about 12% of the exam): High availability and disaster recovery: multi-data center and multi-region design patterns; Infrastructure provisioning and cluster sizing guidelines; Metadata management: legacy ZooKeeper-based setups and KRaft (Apache Kafka Raft) mode
- Kafka Connect (about 11% of the exam): Deploy, configure, and scale standalone and distributed Kafka Connect workers; Manage source and sink connectors for streaming data between external systems and Kafka; Fault tolerance, offset management, and error-handling configurations for connectors
- Observability (about 10% of the exam): Monitor cluster health and performance metrics using JMX (Java Management Extensions); Configure critical metrics, alerting thresholds, and performance counters (bytes-in/out, request latencies, active controller count, under-replicated partitions)
Labs
103 labs, 99 of them graded: you write the code, it runs, and graded labs check the result. The outline lists each lesson's labs.
What is free
Start free: First module free with an account. Pro: Every course, lab, handbook, practice exam and certificate.
- Pro monthly — $29 a month. Every course, lab, handbook, practice exam and certificate
- Pro yearly — $249 a year. Every course, lab, handbook, practice exam and certificate
Course outline
Start Here
- The Payment That Was Charged Twice (2 labs): You can trace a duplicate charge to a producer retry and a consumer commit, fix each side, and say which exam asks about which.
- Ninety Minutes, No Question Count (3 labs): You can plan study time from each exam's estimated weights, pace a paper with no published question count, and work matching and list order items.
Kafka Fundamentals
- The Queue That Forgot (2 labs): You can explain Kafka's log model: topics, partitions, offsets and keys, and how consumer groups split or copy the work.
- Where A Record Lands (3 labs): You can say where Kafka guarantees order, trace a key to its partition, and choose keys and a partition count that keep the order you need.
- Acknowledged Is Not Always Safe (3 labs): You can say what acks 0, 1 and all promise, read the ISR and high watermark, and set min.insync.replicas so one broker can fail without losing acknowledged writes.
- The Error Storm That Fixes Itself (3 labs): You can follow a produce and a fetch from bootstrap to leader, find a group's coordinator, and explain where KRaft keeps the cluster's metadata.
- Retention Deletes Files, Not Records (3 labs): You can predict when retention deletes a record, set retention and segment settings at broker and topic level, and choose a compression codec for a topic.
- Log Compaction: A Topic As A Table (5 labs): You can create a compacted Kafka topic, produce multiple updates for the same key, fold the full log into a key-value table with the console consumer, and explain why compaction converges the log to the same result over time.
- Replay Everything Since Eleven (3 labs): You can create, grow and configure topics, produce and consume keyed records, and reset a consumer group's offsets with the Kafka 4 command-line tools.
Developer Track: Application Development
- The Retry That Overtook (2 labs): You can explain how retries reorder records and how idempotence prevents it, work out how long a producer keeps trying, and pick settings for each delivery guarantee.
- Two Copies Of One Service (3 labs): You can write a read-process-write unit as a transaction, explain how a transactional id fences a zombie, and predict what read_committed consumers see.
- Too Slow Between Two Polls (3 labs): You can size a poll loop against max.poll.interval.ms, place commits for at-most-once or at-least-once, and choose auto.offset.reset for a new group.
- Twenty Seconds Of Nothing (3 labs): You can compare range, round robin, sticky and cooperative sticky assignments, cut rebalances with static membership, and turn on the new consumer protocol.
- The Field The Registry Refused (3 labs): You can read the Confluent wire format, predict which schema changes each compatibility level accepts, and choose who upgrades first.
- Works On A Laptop, Fails In Production (2 labs): You can build a client truststore with the real tools, write client settings for TLS, mutual TLS and SASL, and match each connection failure to the missing setting.
Developer Track: Kafka Streams
- Blank Names After Every Deploy (3 labs): You can read records as a KStream or a KTable, predict a stream-table join's output, and check co-partitioning before a join starts.
- Forty Minutes To Count Again (3 labs): You can explain how state stores and changelogs survive a task move, size restore time, use standby replicas, and route an interactive query.
- Two Hours Of Scans At Once (3 labs): You can predict which tumbling, hopping, session or sliding windows count a record, and which late records grace keeps or drops.
Developer Track: Testing And Observability
- Green Tests, Red Production (3 labs): You can choose between MockProducer, MockConsumer, an embedded broker and TopologyTestDriver, make a mock fail on purpose, and drive stream time in a topology test.
- The Alert That Came An Hour Late (2 labs): You can match producer and consumer metrics to the symptoms they reveal and find the matching lines in a client log.
- Stuck On One Record (3 labs): You can recognise a poison pill, skip it safely with a seek and a dead letter topic, and tell lag caused by one stuck partition from lag caused by a slow group.
Kafka Connect: Both Tracks
- Twelve Lines Instead Of Four Hundred (3 labs): You can explain connectors, tasks, workers and converters, start a distributed worker with the settings it requires, and predict how many tasks a connector runs.
- Change Data Capture In Principle (4 labs): You can start a Postgres instance with logical replication enabled, create a replication slot using the test decoding plugin, and read the change stream produced by insert and update statements to explain how a connector such as Debezium turns those changes into Kafka events.
- The Connector That Was Created Twice (2 labs): You can drive Connect's REST API safely, configure a Debezium source, and predict the change events and topics it produces.
- A Sink That Died On Record Nine (2 labs): You can choose between failing, skipping and parking bad records in a sink, read the dead letter headers, and find a connector's offsets and lag.
Administrator Track: Cluster Configuration
- The Setting That Came Back (2 labs): You can predict which level a broker setting comes from, choose thread and disk settings, and make the producer, broker and topic size limits agree.
- Two Brokers Down (2 labs): You can choose a replication factor and min.insync.replicas for the failures a topic must survive, explain unclean leader election, and size a KRaft controller quorum.
- The New Broker That Did Nothing (2 labs): You can plan and execute a partition reassignment with a throttle, restore preferred leaders, and remove a broker without losing copies.
Administrator Track: Security
- The Certificate That Expired On A Sunday (2 labs): You can build and inspect a broker keystore, catch an expiring certificate early, renew it without a restart, and predict the principal a TLS client gets.
- Where Is The Password Kept? (3 labs): You can choose a SASL mechanism for a listener, explain what the cluster stores for SCRAM users, and map Kerberos principals to the names ACLs match.
- Allowed To Read, Refused Anyway (2 labs): You can write least-privilege ACLs with literal and prefixed patterns, predict the standard authorizer's decision including deny precedence and implied Describe, and avoid wildcard fixes.
Administrator Track: Troubleshooting
- Forty One Under-Replicated Partitions (2 labs): You can triage a broker failure with the topics tool's partition filters, explain why replicas fall out of the ISR, and decide when it is safe to restart another broker.
- Eleven Thousand Scans That Never Arrived (2 labs): You can explain the three common ways records go unconsumed, predict where a group starts, and stop rebalance storms with timeouts and static membership.
- Forty Minutes To Start (2 labs): You can read a broker's logs after a crash, explain log recovery and segment files, and handle a failed log directory without losing data.
Administrator Track: Deployment And Observability
- The Data Centre That Went Dark (2 labs): You can choose between a rack-aware stretched cluster and MirrorMaker 2 for disaster recovery, predict replica placement, remote topic names and translated offsets.
- Full Disks On Black Friday (3 labs): You can size disk, network, partitions, memory and open-file limits for a Kafka cluster's peak load.
- The Upgrade That Could Not Start (2 labs): You can explain ZooKeeper and KRaft metadata management, plan an upgrade path to Kafka 4, and format KRaft storage with a valid cluster id.
- Two Controllers At Once (2 labs): You can find Kafka metrics over JMX, choose which broker and controller metrics page and which warn, and set thresholds for them.
Mock Exams And Review
- Seventy One Percent (2 labs): You can sit the developer mock under exam conditions, review it by weighted domain and by reason, and plan the days before the CCDAK exam.
- The Night Before The Administrator Exam (2 labs): You can sit the administrator mock, tell apart the pairs the exam swaps, predict a whole cluster's behaviour end to end, and go into the CCAAK exam prepared.