What is the Confluent CCDAK certification?

The Confluent Certified Developer for Apache Kafka is the industry-standard credential for engineers who build real-time streaming data applications. Issued by Confluent — the company founded by Apache Kafka’s original creators at LinkedIn — the CCDAK validates deep, hands-on knowledge of the Kafka ecosystem: from the core broker architecture that moves billions of events per day at companies like Uber, Netflix, and Airbnb, to the stream processing layer (Kafka Streams), the data integration layer (Kafka Connect), the schema management layer (Schema Registry), and the SQL abstraction (ksqlDB) that enables teams without JVM expertise to query real-time event streams.

Apache Kafka has become the backbone of modern data infrastructure. As organizations migrate from batch-oriented ETL pipelines to real-time event-driven architectures — powering fraud detection, personalization engines, IoT telemetry, financial transaction processing, and AI feature stores — the demand for engineers who can build and operate Kafka at production scale has grown sharply. In 2026, Kafka powers an estimated 80% of Fortune 100 data pipelines in some capacity, and CCDAK has emerged as the primary credential proving that an engineer understands not just how to use Kafka, but why specific design choices (partition count, replication factor, consumer group topology, serialization format, offset commit strategy) produce the reliability and throughput guarantees production systems require.

CCDAK is distinct from the Confluent Certified Operator for Apache Kafka (CCOAF), which focuses on infrastructure administration: configuring brokers, tuning JVM settings, managing cluster health, capacity planning, and Confluent Platform enterprise features. CCDAK tests the application developer and data engineer who consumes Kafka as a platform — writing producers and consumers, designing topic schemas, building Kafka Streams topologies, wiring Kafka Connect pipelines — rather than the operator who manages the platform itself.

Exam format and domains

CCDAK is administered as an online proctored exam via Confluent’s certification portal. The fee is $150 USD. The exam contains 60 questions to be answered in 90 minutes. Questions are multiple choice (single correct answer) and multiple select (two or more correct answers). There is no partial credit on multiple-select questions; all correct options must be selected. The passing score is reported as a scaled percentage, and Confluent recommends a minimum of 6–12 months of hands-on Kafka development experience before attempting the exam. There are no formal prerequisites — any candidate can register — but the exam is known for testing nuanced behavioral differences between configuration options that only become clear through real-world debugging, not just reading documentation.

Domain Coverage
1. Apache Kafka Core Concepts~20%
2. Kafka Producers~17%
3. Kafka Consumers & Consumer Groups~20%
4. Kafka Streams~18%
5. Kafka Connect~13%
6. Confluent Schema Registry & ksqlDB~12%

Domain 1: Apache Kafka Core Concepts — ~20%

This domain covers the foundational Kafka architecture that underpins every other topic on the exam. Candidates must understand the Kafka broker cluster model: how brokers elect a controller, how partition leadership is distributed across brokers, and what happens to producer and consumer clients during a leader election (they receive a NotLeaderForPartitionException and must retry). The domain tests topic design in depth: the implications of partition count (determines parallelism ceiling for consumers; cannot be decreased without deleting the topic), replication factor (3 is the production minimum; controls how many broker failures a topic tolerates), and the min.insync.replicas configuration (works with producer acks=all to enforce durability guarantees).

Candidates must also understand Kafka’s log compaction feature (retains the latest value per key, enabling Kafka to act as a changelog or materialized view source), log retention (time-based and size-based policies for topics that don’t use compaction), and the role of ZooKeeper vs. KRaft in cluster metadata management. Since Kafka 3.3, KRaft mode (Kafka Raft metadata) has replaced ZooKeeper as the consensus mechanism in new deployments — the exam tests both models and candidates should know that KRaft eliminates the ZooKeeper dependency, simplifies deployment, and enables larger cluster sizes. The Confluent Platform adds enterprise features (Confluent Control Center, tiered storage, cluster linking) that appear in CCDAK questions in the context of operational scenarios, not deep administration.

Domain 2: Kafka Producers — ~17%

The producer domain tests the mechanics of writing data reliably to Kafka topics. The most heavily tested configuration is the acknowledgment model: acks=0 (fire-and-forget — maximum throughput, zero durability), acks=1 (leader acknowledges — risk of data loss if the leader fails before followers replicate), and acks=all (all in-sync replicas acknowledge — strongest durability guarantee; works with min.insync.replicas to control the minimum number of replicas that must confirm). Candidates must understand the idempotent producer (enable.idempotence=true): setting it to true automatically sets acks=all, max.in.flight.requests.per.connection=5, and retries=Integer.MAX_VALUE, ensuring that duplicate messages caused by network retries are deduplicated at the broker.

Transactional producers build on idempotency to provide exactly-once semantics across multiple topic partitions: the producer calls initTransactions(), wraps writes in beginTransaction() / commitTransaction(), and aborts with abortTransaction() on failure. This is the mechanism that enables exactly-once semantics (EOS) in Kafka Streams. The domain also covers partitioning strategy: the default partitioner uses key hash (consistent partition assignment for keyed messages), round-robin for null-key messages, and the sticky partitioner (batches null-key messages to a single partition until the batch is sent, reducing small-batch overhead). Candidates must know when to implement a custom partitioner and the consequences of key skew (hot partition problem).

Domain 3: Kafka Consumers & Consumer Groups — ~20%

Consumer behavior is the domain with the highest density of exam questions because consumer group mechanics are subtle and frequently misunderstood. The exam tests the consumer group protocol in depth: how partitions are assigned to consumers via group coordinator and group leader, what happens during a rebalance (all consumers stop processing while partitions are reassigned — the exam expects candidates to know how to minimize rebalance frequency using cooperative rebalancing, session.timeout.ms, and heartbeat.interval.ms), and what triggers a rebalance (new consumer joins, consumer leaves or fails to heartbeat, new partitions added to a subscribed topic).

Offset management is critical exam content. Candidates must understand the difference between committed offsets (the last offset a consumer acknowledged as processed, stored in the internal __consumer_offsets topic) and the current position (the next offset to fetch). auto.commit.enable=true with auto.commit.interval.ms commits offsets on a timer — if the consumer crashes between commit and processing, messages are reprocessed (at-least-once delivery). Manual offset commit with commitSync() (blocks until the broker acknowledges) or commitAsync() (non-blocking, requires a callback for retry logic) gives the consumer precise control over when offsets are committed. The auto.offset.reset setting (earliest reads all available messages from partition start; latest reads only new messages arriving after the consumer started; none throws an exception if no committed offset exists) determines behavior when a consumer group has no committed offset for a partition.

Domain 4: Kafka Streams — ~18%

Kafka Streams is a Java library for building stateful and stateless stream processing applications that read from and write to Kafka topics. The exam tests the topology model: source processors (read from topics), stream processors (apply transformations), and sink processors (write to topics). The high-level DSL abstractions tested include KStream (a record stream — each record is an event), KTable (a changelog stream — latest value per key, like a materialized table), GlobalKTable (a KTable that is fully replicated to all application instances, enabling non-partitioned joins), and KGroupedStream / KGroupedTable (grouped records awaiting aggregation).

Stateful operations — joins, aggregations, and windowing — are heavily tested because they require an understanding of Kafka Streams state stores. State stores are backed by RocksDB (for persistent, disk-backed storage) and changelog topics (for fault tolerance: the state store can be rebuilt from the changelog after a failure). Candidates must understand the join semantics: KStream-KStream joins require a window (windowed join); KStream-KTable joins are non-windowed (the KTable acts as a lookup table); KStream-GlobalKTable joins do not require co-partitioning. Windowing types tested include tumbling windows (fixed, non-overlapping), hopping windows (fixed-size, overlapping), and session windows (dynamically sized based on inactivity gaps). The exam also tests exactly-once processing in Kafka Streams: setting processing.guarantee=exactly_once_v2 enables EOS within a Kafka Streams application by combining transactional producers and idempotent consumers.

Domain 5: Kafka Connect — ~13%

Kafka Connect is the integration layer for moving data between Kafka and external systems (databases, object stores, search indexes, SaaS APIs) without writing custom producer or consumer code. The exam tests the connector architecture: source connectors (import data from external systems into Kafka topics), sink connectors (export data from Kafka topics to external systems), workers (JVM processes that execute connectors and tasks), tasks (units of parallelism within a connector), and the Connect REST API (for deploying, configuring, and monitoring connectors).

Candidates must understand the two deployment modes: standalone mode (single worker process, offset storage in a local file — for development and single-node deployments) and distributed mode (multiple worker processes, offsets and connector configs stored in Kafka internal topics — for production). The exam tests common configuration patterns for the Debezium CDC connector (captures row-level database changes as Kafka events using database transaction logs), the JDBC Source connector (polls a relational database table on a schedule), and the S3 Sink connector (writes Kafka records to Amazon S3 in Avro, JSON, or Parquet format). Candidates are expected to know how Single Message Transforms (SMTs) work to route, filter, rename, or mask fields in records as they flow through a connector pipeline.

Domain 6: Confluent Schema Registry & ksqlDB — ~12%

Confluent Schema Registry provides a centralized schema store for Avro, Protobuf, and JSON Schema — ensuring that producers and consumers agree on data structure. The exam tests schema registration (schemas are registered by subject, named by default as {topic}-value or {topic}-key), schema compatibility modes (BACKWARD: new schema can read data written by old schema; FORWARD: old schema can read data written by new schema; FULL: both; NONE: no compatibility checking), and how producers and consumers use Schema Registry at runtime (the producer serializes records with a schema ID embedded in the payload; the consumer fetches the schema by ID and deserializes accordingly). Avro is the most-tested serialization format; candidates must know the rules for backward-compatible Avro schema evolution (adding optional fields with defaults is backward-compatible; removing required fields or changing field types is not).

ksqlDB is Confluent’s SQL engine for stream processing. The exam tests how to create streams (CREATE STREAM — maps to a KStream), tables (CREATE TABLE — maps to a KTable), push queries (SELECT ... EMIT CHANGES — continuous queries that stream results as new events arrive), and pull queries (SELECT without EMIT CHANGES — point-in-time lookups against materialized state). Candidates are expected to understand the operational model: ksqlDB servers run Kafka Streams under the hood, and ksqlDB queries are translated into Kafka Streams topologies deployed on ksqlDB server instances.

CCDAK vs CCOAF vs Databricks Kafka-adjacent certs: which is right for you?

CCDAK — Confluent Certified Developer

Focus: Building and operating Kafka applications — producer/consumer code, Kafka Streams topologies, Kafka Connect pipelines, Schema Registry, ksqlDB. Target role: Data engineer, streaming engineer, backend developer, platform engineer. Best if: You write code that reads from or writes to Kafka, design streaming data architectures, or build real-time ETL pipelines for analytics or ML feature stores.

CCOAF — Confluent Certified Operator

Focus: Managing Kafka clusters — broker configuration, JVM tuning, capacity planning, security (TLS, SASL, ACLs), Confluent Platform enterprise features. Target role: Platform engineer, SRE, infrastructure engineer. Best if: You administer Kafka clusters, manage Confluent Platform deployments, or are responsible for cluster reliability and operational runbooks.

Databricks Certified Data Engineer Associate

Focus: Data engineering on the Databricks Lakehouse platform — Delta Lake, Spark Structured Streaming, Unity Catalog, DLT pipelines. Target role: Data engineer working in the Databricks ecosystem. Best if: Your team uses Databricks for both batch and streaming workloads and Kafka is consumed via Databricks Structured Streaming rather than native Kafka clients. CCDAK and Databricks certs are complementary for engineers bridging the Kafka event layer with the Lakehouse analytics layer.

CCDAK and the Databricks Data Engineer Associate are increasingly held together by data platform engineers in 2026, particularly at companies where Kafka serves as the event backbone and Databricks Structured Streaming (with Delta Lake as the sink) serves as the processing and storage layer. The two certs address complementary layers of the modern data stack: CCDAK covers the event transport and stream processing layer; the Databricks cert covers the lakehouse query and transformation layer. Engineers who hold both are positioned for senior platform engineering and data architecture roles that span the full pipeline from event source to analytics endpoint.

Key topics to master for CCDAK

Exactly-Once Semantics (EOS) The most nuanced CCDAK topic. Know the three layers: idempotent producer (deduplicates retried messages at the broker), transactional producer (atomic multi-partition writes), and Kafka Streams EOS (processing.guarantee=exactly_once_v2). Understand the read-committed consumer isolation level and why it matters when reading from transactional topics.
Consumer Group Rebalancing Know the difference between eager rebalancing (all partitions revoked before reassignment — causes a processing pause) and cooperative rebalancing (only partitions that change hands are revoked — minimizes pause). Know the role of session.timeout.ms, heartbeat.interval.ms, and max.poll.interval.ms in controlling consumer liveness detection. Know how static group membership (group.instance.id) reduces rebalances for stateful consumers.
Kafka Streams Joins & Windows Know which joins require co-partitioning (KStream-KStream, KStream-KTable) vs. which do not (KStream-GlobalKTable). Know tumbling vs. hopping vs. session window semantics. Know how grace periods affect late-arriving events in windowed aggregations. Know the difference between stream-time and wall-clock-time in Kafka Streams windowing.
Schema Evolution with Avro Know the BACKWARD / FORWARD / FULL / NONE compatibility modes and which schema changes are permitted under each. Know that adding a field with a default value is backward-compatible; removing a field without a default is not. Know how Schema Registry embeds the schema ID in the Avro wire format (magic byte + 4-byte schema ID prefix).
Kafka Connect Reliability Know how distributed Connect ensures fault tolerance (tasks are redistributed when a worker fails). Know how offset storage works for source connectors (offsets stored in an internal Kafka topic, enabling source connectors to resume from the last processed position after a restart). Know how to use SMTs for record routing, field masking, and format conversion without writing custom connector code.
Producer & Consumer Throughput Tuning Know the key throughput configurations: producer batch.size and linger.ms (batching controls), compression.type (lz4 for throughput; gzip for compression ratio), buffer.memory. Consumer fetch.min.bytes and fetch.max.wait.ms (batching on the fetch side), max.poll.records (controls how many records are returned per poll call). Know when each setting helps and what trade-offs it introduces.

Why streaming data certifications are surging in 2026

The demand for Kafka expertise — and for CCDAK in particular — is being driven by three converging forces in the 2026 data engineering landscape. The first is real-time AI feature stores: machine learning teams are building features from event streams (clickstream, transaction events, IoT signals) for real-time model inference, and Kafka has become the standard transport layer that feeds both the feature computation pipeline and the feature serving store. Companies building recommendation engines, fraud detection systems, and real-time personalization need engineers who understand Kafka’s delivery guarantees and can design low-latency consumer topologies.

The second driver is event-driven microservices: as organizations decompose monolithic applications, they increasingly use Kafka as the communication bus between services — replacing synchronous REST or gRPC calls with asynchronous event streams that decouple producers from consumers, enable replay of historical events for new services, and provide a durable audit log of all state changes. Engineers who understand Kafka’s exactly-once semantics can design microservice architectures that guarantee consistency across service boundaries without distributed transactions.

The third driver is regulatory compliance: financial services, healthcare, and regulated industries increasingly require real-time event logging for audit trails, fraud detection, and GDPR right-to-erasure pipelines. Kafka’s log compaction and retention policies, combined with Schema Registry for data governance, make it the platform of choice for compliance-grade event streaming — and CCDAK validates the expertise to implement these patterns correctly.

CCDAK is the credential that proves you understand not just how to send messages to Kafka, but how to design a streaming data architecture that is reliable, ordered, and correct at scale — from exactly-once semantics to schema governance to consumer group fault tolerance.

Salary impact and career outcomes

CCDAK holders command strong salaries in North American markets in 2026, reflecting the persistent shortage of engineers with deep Kafka expertise. Data engineers and backend engineers with CCDAK certification earn median base salaries of $110,000 to $150,000, depending on industry and experience level. Senior streaming engineers who architect Kafka-based data platforms end-to-end — from topic design through Kafka Streams topologies to downstream lakehouse integration — reach $155,000 to $175,000 at data-intensive companies in finance, technology, and retail.

The job titles most associated with CCDAK in 2026 postings include: Streaming Data Engineer, Real-Time Platform Engineer, Data Platform Architect, Event-Driven Systems Engineer, Backend Engineer (Kafka / Streaming), and Staff Data Engineer. Financial services roles (investment banks, payment processors, trading platforms) are the highest-paying market for CCDAK holders, where real-time transaction processing and fraud detection pipelines require the low-latency, exactly-once guarantees that Kafka provides. Technology companies with large-scale recommendation and personalization systems represent the second-largest market, followed by logistics and supply-chain companies deploying IoT event streaming.

Who should pursue CCDAK in 2026

Data Engineers Building Real-Time Pipelines Engineers who design and build event-driven data pipelines from operational systems into analytics platforms. CCDAK validates the producer, consumer, and Kafka Connect knowledge needed to build reliable, exactly-once data ingestion pipelines without message loss or duplication.
Backend Engineers in Event-Driven Architectures Software engineers building microservices that communicate via Kafka event streams rather than synchronous REST calls. CCDAK validates the consumer group design, offset management, and schema governance knowledge that production event-driven systems require.
ML Engineers Building Feature Stores Machine learning engineers who use Kafka to stream features from operational data sources to online feature stores for real-time model inference. CCDAK validates the low-latency consumer and Kafka Streams knowledge needed to compute and serve features at millisecond latency.
Platform Engineers Adding Streaming to the Stack Infrastructure and platform engineers who are deploying Kafka as a shared streaming infrastructure within their organization. CCDAK gives platform engineers the developer-side context they need to design topic schemas, partition strategies, and consumer group topologies that serve application teams correctly.
Databricks / Spark Engineers Adding Kafka Depth Engineers who already hold Databricks certifications and use Spark Structured Streaming to consume from Kafka topics. CCDAK fills in the Kafka-side knowledge gaps — producer semantics, exactly-once, Schema Registry, consumer group mechanics — that Spark-focused training does not cover.
Architects Evaluating Streaming Platforms Solutions architects and technical leads evaluating Kafka vs. Kinesis, Pulsar, or RabbitMQ for new streaming workloads. CCDAK validates the depth of Kafka knowledge needed to make informed platform selection decisions and design architectures that take advantage of Kafka’s unique guarantees.

Study approach and resources

Confluent provides a free CCDAK exam study guide on the Confluent certification site, listing the exact topics and percentage weights for each domain. The most important preparation resource is Confluent’s own Kafka 101 and Kafka Internal Architecture courses on the Confluent Developer portal (free), which cover the broker internals, replication protocol, and consumer group coordinator mechanics that underpin the hardest CCDAK questions. Confluent also offers a paid Apache Kafka for Developers training course that maps directly to the CCDAK blueprint and includes hands-on labs on Confluent Cloud (the managed Kafka service).

For hands-on preparation, running a local Kafka cluster with Docker Compose is sufficient for all producer, consumer, and Kafka Streams labs. The Confluent Developer portal provides ready-to-run tutorials for each CCDAK domain. Candidates should focus practical time on: implementing an idempotent producer and verifying deduplication behavior, writing a transactional producer with manual abort-on-error handling, building a Kafka Streams topology with a KStream-KTable join and a tumbling-window aggregation, deploying a Debezium CDC source connector and an S3 sink connector in distributed mode, and registering Avro schemas with Schema Registry under BACKWARD compatibility and verifying that incompatible schema changes are rejected.

CCDAK’s most commonly failed areas are consumer offset commit semantics (candidates confuse commitSync vs. commitAsync failure handling, and misunderstand the at-least-once vs. exactly-once delivery guarantees each provides), Kafka Streams state store mechanics (candidates underestimate how changelog topics and standby tasks affect state recovery latency after a worker failure), and Schema Registry compatibility rules (candidates confuse BACKWARD and FORWARD compatibility directions). Targeted practice on these three areas catches the majority of gaps that cause failures on the real exam.

Confluent Developer Portal — free CCDAK exam prep

Confluent’s free developer portal at developer.confluent.io includes structured learning paths for producers, consumers, Kafka Streams, Kafka Connect, and Schema Registry that align directly with the CCDAK blueprint. The platform includes interactive coding exercises, end-to-end tutorials, and Confluent Cloud sandbox environments. The official CCDAK exam guide (free download from the Confluent certification page) lists the exact services, configurations, and behavioral scenarios that appear on the exam — treating it as a study checklist is the most efficient preparation strategy.

Practice Apache Kafka questions free on CertQuests.

Kafka Practice Questions →