Confluent Kafka Developer study plan

Stand up a local single-broker cluster in KRaft mode and create a 3-partition topic with explicit partition and retention settings

Produce and consume records from the CLI and record how key-based partitioning changes which partition a record lands in

Trace a record from producer to consumer by mapping offset, log-end-offset, and consumer position for one consumer group

Explain leader/follower/ISR behavior and write down what acks=all with min.insync.replicas=2 protects against

Trigger and observe a consumer-group rebalance by starting a second consumer and then killing a member, logging each state transition

Compare range, round-robin, and cooperative-sticky assignors on the same topic and justify a choice for a skewed-key workload

Derive effective delivery semantics by combining acks, enable.idempotence, and isolation.level in a matrix of at least six configurations

Write three producer configuration profiles (latency-first, throughput-first, durability-first) and defend every non-default setting

Choose a partition key strategy that preserves per-entity ordering without creating hot partitions

Implement an at-least-once consumer that commits offsets manually only after downstream writes succeed, and prove no message is lost when the consumer is killed mid-batch

Implement an idempotent write path and verify duplicate redelivery does not create duplicate rows

Size partition count and key selection for a pipeline with a stated ordering and throughput requirement, showing the arithmetic

Run a Kafka Connect source connector and sink connector end to end with explicit key/value converters

Build an end-to-end pipeline that survives poison-pill records by routing failures to a dead-letter topic with the exception details preserved

Configure Connect error tolerance and retry behavior and demonstrate both a tolerated and a failed task

Tune consumer fetch.min.bytes, fetch.max.wait.ms, and max.poll.records for a stated latency target and measure the effect

Handle a deserialization failure on the consumer side without stalling the partition

Register schemas for a subject and set compatibility to BACKWARD, then attempt at least four schema evolutions and classify each as accepted or rejected

Reproduce a compatibility failure and read the Schema Registry error response to identify the offending field change

Configure a Connect worker with Schema Registry-backed converters and a single-message transform, and confirm the transform output in the sink

Explain how subject naming strategies affect schema sharing across topics

Write a Kafka Streams topology that performs a stateful aggregation over a tumbling window and inspect the resulting state store

Enable exactly-once processing guarantees and demonstrate that a forced restart does not duplicate aggregate output

Apply access controls so one principal can write to a topic and another can only read it, then verify the denial

Map governance requirements to concrete controls: audit logging, data contracts enforced by schema compatibility, and lineage tracking across the pipeline

Re-run every weak-area item flagged in earlier self-checks and close each one with a written explanation

Work timed question sets per domain and log error causes by category rather than by topic

Re-derive delivery semantics, rebalance behavior, and schema compatibility rules from memory and correct against notes

Review Connect worker versus connector versus task responsibility boundaries until you can state them without notes

Complete two full-length timed practice runs and record per-domain accuracy

Re-teach the two lowest-scoring domains from scratch using only official documentation

Verify every configuration value used in your projects against current documentation and fix any deprecated or misremembered setting

Write a one-page decision cheat sheet for the choices the exam repeats: partitioning, delivery semantics, connector topology, serialization format, and stream processing guarantees