Kafka and message brokers series: 1. Message brokers: four problems with request-response and how to choose a broker · 2. Why Kafka is fast and durable: the log, zero-copy, batching and replication · 3. Tuning Kafka for your goal: throughput, latency, durability, availability · 4. Case study: a synchronous fraud check over Kafka and Redis — good idea or not? · 5. CCDAK review: 40 Kafka questions worth remembering
CCDAK (Confluent Certified Developer for Apache Kafka) checks whether you understand Kafka the way an application developer needs to: producers, consumers, offsets, replication, plus a bit of Streams, Schema Registry and Connect. These are 40 questions I wrote for daily review, each with a short answer and the reasoning; it is not the real exam or a “dump”. Read Why Kafka is fast and durable and Tuning Kafka for your goal first, where most answers are explained in depth. After these 40, continue with part 2: 34 questions on clients, Connect, Schema Registry and Streams.
At a glance:
mindmap
root((CCDAK exam prep))
KRaft replaces ZooKeeper
Metadata is records in a log
Durability
acks=all, RF 3, min ISR 2
Consumer
auto.offset.reset only without offset
Commit before or after processing
More partitions remap keys
Schema Registry rejects schemas
Trap: old ZooKeeper dumps
1. The exam and how to prepare
Key idea: a 90-minute proctored online exam, certification valid for 2 years. Prepare with the official outline, the Kafka docs and a local cluster, not with dumps.
- Format: webcam-proctored, with single/multiple-choice, matching and ordering questions. The course slides mention about 60 questions and a 150 USD fee; check Confluent’s official certification page, because these numbers change.
- Official material: Confluent’s CCDAK exam preparation guide (the outline; check there whether Confluent offers sample questions), the Apache Kafka documentation, and a local cluster (the lab in post 3).
- Value: a good way to validate your knowledge, moderate value on a CV. One to three months of preparation if you already use Kafka, longer if not.
- Exam tip: there is no negative marking, so answer every question. Flag hard ones, move on, and come back.
Knowledge domains in the exam outline
- Application design: CLI tools, pub/sub, message metadata, key selection, schema management, metrics.
- Development: producers/consumers, ordering and delivery guarantees, serdes (serializers/deserializers), offsets, consumer groups and rebalancing, retention, co-partitioning, performance.
- Deployment and testing: security, client monitoring, Streams, ksqlDB.
2. ZooKeeper-era answers and their KRaft equivalents
Key idea: since Kafka 4.0 (2025), everything that used to live in a ZooKeeper znode is a record in the __cluster_metadata log, written by a group of controllers running the Raft protocol (KRaft). When an old question mentions ZooKeeper, answer what it asks, but keep the KRaft answer ready.
Raft is a consensus protocol: a group of nodes elects a leader, and a change is accepted only when a majority agrees.
| Old question | ZooKeeper-era answer | KRaft equivalent |
|---|---|---|
| Where are ACLs stored | znode /kafka-acl/... |
records in __cluster_metadata, StandardAuthorizer |
| Where is dynamic topic config stored | znode /config/topics/<topic> |
records in __cluster_metadata; inspect with kafka-configs --bootstrap-server ... --describe |
| How is the controller elected | the first broker to create the ephemeral /controller znode wins |
leader of the Raft quorum, needs a majority of voters |
| How many nodes can a 5-node ensemble lose | 2 (needs a majority of 3/5) | a 5-voter controller quorum also survives 2 |
| Ports | 2181 (client), 2888 (follower), 3888 (leader election) | the CONTROLLER listener (often 9093), declared in controller.quorum.voters or controller.quorum.bootstrap.servers (3.9+) |
| CLI | kafka-topics --zookeeper host:2181 |
--bootstrap-server host:9092 (--zookeeper removed from kafka-topics in 3.0) |
| Inspect metadata state | zkCli.sh |
kafka-metadata-quorum --bootstrap-server ... describe --status |
Answers I verified in a lab
On a three-node KRaft cluster (cp-kafka 7.5.3, client 4.1.1):
- Calling
subscribe()and thenassign()on the same consumer throwsIllegalStateException. - 30 keyless records sent in one burst all land in one partition (sticky).
kafka-console-consumerwithout--groupcreates a group calledconsole-consumer-11563.- Wiping a broker’s data and restarting it: it catches up and rejoins the ISR (
Isr: 1,2,3).
3. Cluster, replication and KRaft
Key idea: cluster metadata is managed by a single active controller (the quorum leader), and the quorum needs a majority alive. Clients never ask the controller; they ask any broker for metadata.
1. Where are Kafka ACLs stored?
KRaft: as metadata records in the __cluster_metadata log. ZooKeeper era: under the /kafka-acl znode.
In KRaft the records are replicated by the controller quorum and enforced by StandardAuthorizer. In neither case do they live in the broker’s data directory or in a user-readable topic.
2. Where does a topic’s dynamic config (e.g. retention.ms changed with kafka-configs) live?
In __cluster_metadata (KRaft) or the /config/topics/<topic> znode (ZooKeeper), not in server.properties.
server.properties is the broker’s static config. Inspect dynamic config with kafka-configs --bootstrap-server ... --entity-type topics --entity-name <topic> --describe.
3. What does the controller do, and how is it chosen?
The controller manages cluster metadata; in KRaft it’s the leader of the Raft quorum, elected by a majority of voters.
- Its job: elect partition leaders when a broker dies, track brokers joining and leaving, record topic changes.
- It does not coordinate consumer group rebalances; that’s the group coordinator on the brokers.
- ZooKeeper era: whichever broker created the
/controllerznode first. - Only one controller is active at a time, regardless of how many producers or consumers there are.
4. How many nodes can a 5-node quorum lose?
Two, because a majority (3/5) must stay alive.
This holds for both a ZooKeeper ensemble and a KRaft controller quorum. That’s why node counts should be odd: 4 nodes tolerate only one failure, the same as 3. In the ZooKeeper era nodes talked over 2181 (clients), 2888 (followers to leader) and 3888 (leader election); KRaft uses the CONTROLLER listener.
5. With a replication factor of 3, where does each partition’s data live?
On 3 different brokers, one replica each: one leader, two followers.
You can’t set an RF larger than the number of brokers; creating an RF=3 topic on a 2-broker cluster is rejected. With broker.rack, Kafka also spreads replicas across racks/AZs.
6. A broker’s disk is wiped and the broker restarts — what happens?
It rejoins as an empty follower, re-fetches from the leaders and joins the ISR only once it has caught up; no data is lost.
- With unclean election disabled, it can’t become leader before catching up.
- In KRaft the log directory must contain
meta.properties(cluster id, node id), so you runkafka-storage formatfirst (the Confluent image does it automatically whenCLUSTER_IDis set). - If that node is also a controller voter, be more careful: since 3.9 (KIP-853) there is a proper procedure for replacing voters.
7. A client gets NOT_LEADER_OR_FOLLOWER on a fetch — what does it do?
It sends a metadata request to any broker, learns the new leader and retries against it.
Every broker can answer metadata requests; clients never ask ZooKeeper or the controller directly. The error used to be called NOT_LEADER_FOR_PARTITION. Producers handle leader changes the same way, so with RF ≥ 2 losing a leader doesn’t stop a producer.
4. Producers
Key idea: the producer trades durability for speed through acks, batches records for throughput, and retries transient errors on its own. Since Kafka 3.0 the defaults are acks=all and idempotence on.
The ISR (in-sync replicas) is the set of replicas keeping up with the leader. Idempotence means the broker spots and drops duplicates caused by retries.
8. What are the three mandatory producer settings, even without keys?
bootstrap.servers, key.serializer, value.serializer.
You still need a key serializer when you never send keys. Since Kafka 3.0 the defaults are acks=all and enable.idempotence=true, but set them explicitly anyway.
9. What does producer.send() return in Java?
A Future<RecordMetadata> (topic, partition, offset, timestamp).
There’s an overload taking a Callback that runs when the broker responds or the send fails. Calling .get() on every record makes the producer synchronous and kills throughput.
10. What’s the risk of max.in.flight.requests.per.connection > 1 combined with retries?
Reordering: batch 1 fails and is resent after batch 2 succeeded, so batch 2 ends up first in the partition.
With enable.idempotence=true the broker uses the producer id and sequence numbers to keep order and drop duplicates, allowing up to 5 in-flight requests. If you disable idempotence and need ordering, set it to 1.
11. What do you set to get acknowledgement from the leader only?
acks=1.
acks=0 waits for nothing, acks=all (or -1) waits for every replica in the ISR. With acks=1, if the leader dies before followers copy the record, an acknowledged record can be lost.
12. Which three settings give the strongest durability while still surviving one broker failure?
acks=all, replication factor 3, min.insync.replicas=2.
Every write sits on at least 2 brokers before it’s acknowledged, and losing one broker still allows writes. RF=3 with min ISR 1 may let acks=all write a single copy; RF=2 with min ISR 2 stops writes when one broker dies.
13. Whose settings are acks and min.insync.replicas, and when does min ISR matter?
acks belongs to the producer, min.insync.replicas to the topic; min ISR only matters when the producer uses acks=all.
Min ISR defaults to the broker’s value. If the ISR is smaller than this value, the broker rejects the write with NotEnoughReplicasException. With acks=0 or 1 it’s ignored.
14. RF=3, min.insync.replicas=1, acks=all: how many brokers can be down while writes still succeed?
Two: all you need is the leader.
An ISR of 1 satisfies a min ISR of 1. The trade-off: an acknowledged record may exist on a single disk.
15. Batches are always full and you want more producer throughput — what do you change?
Increase batch.size and enable compression.type (lz4 or zstd).
- Compression works per batch, so bigger batches compress better and save network and disk.
- If batches aren’t full yet, raise
linger.msto wait for more records. - Raise
buffer.memoryif the producer blocks because its buffer is full.
16. Which errors can the producer retry, and which can’t it?
Transient errors are retriable; errors caused by the request itself (too large, not authorised, bad config) are not.
- Retriable:
NOT_ENOUGH_REPLICAS,NOT_LEADER_OR_FOLLOWER,REQUEST_TIMED_OUT, network errors. - Non-retriable (retrying won’t help):
MESSAGE_TOO_LARGE,TOPIC_AUTHORIZATION_FAILED,INVALID_REQUIRED_ACKS, serialisation errors. - The producer retries transient errors on its own within
delivery.timeout.ms(2 minutes by default); non-retriable errors go straight to the callback.
17. A record with no key, using the default partitioner — which partition does it go to?
Any partition; since 2.4 the producer fills one partition until the batch is full (sticky), then switches.
- Before 2.4: round-robin per record.
- From 2.4: the sticky partitioner switches when the batch is full or
linger.msexpires, which gives bigger batches. - Since 3.3 (KIP-794): the logic is built into the producer (leave
partitioner.classunset) and favours partitions on faster brokers;DefaultPartitioneris deprecated.
In my lab, 30 keyless records sent in one burst all landed in the same partition.
18. What happens when you add partitions to a topic that uses keys?
Old records stay where they are; new records with the same key may go elsewhere because hash(key) % partitions changes.
The log is immutable, so nothing is reshuffled. “Same key, same partition” only holds while the partition count stays the same. Changing the number of brokers, producers or the replication factor doesn’t affect this mapping.
5. Consumers and offsets
Key idea: a committed offset means “done up to here”, and committing before or after processing decides the delivery guarantee. A group splits partitions among its consumers; each partition is read by one consumer in the group.
The high watermark is the highest offset every ISR replica has. A rebalance is when the group redistributes partitions among its consumers.
19. The group committed offset 643, the partition holds offsets 45 to 2311, auto.offset.reset=latest — where does the consumer start?
At 643.
auto.offset.reset only applies when the group has no valid offset for that partition. The committed offset is still within the retained range, so it’s used and latest is ignored.
20. The group committed offset 10 but retained data starts at 45, auto.offset.reset=none — what happens?
The consumer throws an exception: the offset is out of range and there is no reset policy.
none means “don’t guess, tell me”. With earliest it would jump to 45, with latest to the end of the log. This typically happens when a consumer has been stopped for longer than the retention period.
21. A loop calls commitSync() right after poll() and only then processes the records — what delivery guarantee is that?
At-most-once: offsets are committed before processing, so a crash midway means the remaining records are never processed.
Committing after processing gives at-least-once (a crash means reprocessing). For an effectively-once outcome, combine at-least-once with idempotent processing, or store the offsets in the same transaction as the results.
22. A commit of offset 2000 is lost on the network, then a commit of 3000 succeeds. What should you do?
Nothing: 3000 covers 2000.
A commit means “everything up to here is done”. That’s also why commitAsync doesn’t retry by itself: retrying an old commit could overwrite a newer one.
23. What happens if you call subscribe() and then assign() on the same consumer?
IllegalStateException (“Subscription to topics, partitions and pattern are mutually exclusive”); I ran it.
subscribe() uses the consumer group mechanism (the broker distributes partitions), assign() picks partitions manually with no rebalancing. To read exactly partitions 0 and 1, use assign() only.
24. Which events trigger a consumer group rebalance?
A change in group membership or in the set of subscribed partitions.
- A consumer joins the group.
- A consumer leaves or is considered dead: no heartbeat within
session.timeout.ms, or nopollwithinmax.poll.interval.ms. - A subscribed topic gains partitions.
- A new topic matches a subscription pattern.
Producing more messages or adding producers does not.
25. Each batch takes about 6 minutes to process and the consumer keeps getting rebalanced. How do you fix it?
The batch exceeds max.poll.interval.ms (5 minutes by default), so the consumer is kicked out; raise the limit or do less per loop.
- Raise
max.poll.interval.msto fit. - Lower
max.poll.recordsso each loop does less. - Or move the heavy work to another thread and
pause()/resume()the partitions.
Raising session.timeout.ms doesn’t help, because heartbeats run on a separate thread.
26. How do you stop a consumer immediately and shut the application down cleanly?
Call consumer.wakeup() from another thread, catch WakeupException, then close() in a finally block.
For example call it from a shutdown hook; the running poll() throws WakeupException. Commit offsets if needed, then close() so the consumer leaves the group right away instead of waiting for the session timeout. KafkaConsumer isn’t thread-safe; wakeup() is the only method meant to be called from another thread.
27. A producer writes with acks=1 and the followers haven’t replicated yet. When does a consumer see the record?
Once the high watermark moves past the record’s offset, i.e. every replica in the ISR has it.
Consumers can only read up to the high watermark. So acks=1 makes the producer faster but doesn’t let consumers see data sooner; it only lets the producer get an acknowledgement for a record that may later be lost.
28. A partition with RF=3 and min.insync.replicas=2 loses two replicas. Can consumers still read?
Yes: the remaining leader still serves fetches.
Min ISR only blocks producers using acks=all (NotEnoughReplicasException); an acks=1 producer can still write. Min ISR is a rule for writes, not for reads.
29. Two applications (fulfilment and monitoring) both need every order from one topic. How do you set them up?
Give each application its own group.id.
Within a group each partition goes to one consumer, so a shared group would split the messages between the two applications. Each group has its own offsets, so they read independently.
30. The target is 1 GB/s and each consumer handles 50 MB/s. What’s the minimum number of partitions?
20 partitions (1000 / 50), and 20 consumers in the group to reach that rate.
One partition is read by only one consumer in a group. In practice add headroom for growth, because you can’t reduce partitions and adding them changes the key mapping.
6. Topics, retention and compaction
Key idea: retention deletes data by age, compaction keeps the latest value per key; both work only on closed segments. A segment is one file of a partition; the file being written is the active segment.
31. With log.retention.hours=168, log.retention.minutes=168 and log.retention.ms=168 all set, how long is data kept?
168 milliseconds, because precedence is ms > minutes > hours.
The question tests the precedence, not a setting you’d ever use. Note that deletion happens per segment: the active segment isn’t deleted even if it’s past retention.
32. A compacted topic receives a record with key K and a null value. What happens, and when does compaction run?
The record is a tombstone: when the log cleaner runs, every older value of K is removed; the tombstone is kept for delete.retention.ms (24 hours by default), then removed too.
- The tombstone is kept so consumers can see that the key was deleted.
- The cleaner only works on closed segments, when the dirty ratio exceeds
min.cleanable.dirty.ratio(0.5 by default) ormax.compaction.lag.mshas passed. - Written records can’t be modified; to “update” one, write a new record with the same key.
33. A producer writes to a topic that doesn’t exist and the broker has auto.create.topics.enable=true — what happens?
The broker creates the topic with broker settings: num.partitions and default.replication.factor.
The producer can’t pass a partition count. Disable this in production: a typo in a topic name creates a junk topic with default settings, often a single partition. The topic is created as soon as a client sends a metadata request for a missing topic (usually the first produce); the broker default is true, so set it to false in production.
7. Streams, Schema Registry and Connect
Key idea: Streams keeps state in RocksDB and changelog topics named after the application.id; Schema Registry is a separate REST service that decides which schemas may be registered; Connect splits work into tasks by units of data, not by worker count.
34. Which Kafka Streams operators are stateful, and what does a KStream–KTable join return?
Stateful: aggregate, count, reduce, join and windowed operations; a KStream–KTable join returns a KStream.
Stateful operators need a state store (RocksDB) and a changelog topic. Stateless: map, filter, flatMap, branch, peek. In the join, each new stream record looks up the table’s current value.
35. A “purchase” topic has 5 partitions and a “customer” topic has 3; you want to join the stream with the customer table. How?
Use a GlobalKTable for customer, or repartition one side to match.
A KStream–KTable join requires co-partitioning (same partition count, same key partitioning).
- GlobalKTable: every instance holds the whole table; good for small tables, no co-partitioning needed.
- Repartition: an extra intermediate topic and more I/O.
36. How are Streams internal topics named, and which flow does Streams exactly-once cover?
After the application.id; exactly-once covers the Kafka → Kafka flow only.
Names look like <application.id>-<store>-changelog and -repartition, so changing application.id loses your state. Exactly-once (processing.guarantee=exactly_once_v2) wraps read, process, write and offset commit in one transaction; side effects such as HTTP calls or writes to another database aren’t included.
37. A Streams app on Kubernetes takes ages to restart because it rebuilds its state. How do you improve that?
Mount a persistent volume for state.dir and add standby replicas.
- A persistent volume for the state directory (RocksDB): a restart replays only the missing part of the changelog instead of all of it.
num.standby.replicas: tasks can move to an instance that already has a copy of the state.
More partitions or more threads don’t remove the need to replay the changelog.
38. Where does Schema Registry store schemas, what protocol does it speak, and who rejects an incompatible schema?
In the compacted _schemas topic, over REST (HTTP/HTTPS), and Schema Registry itself rejects incompatible schemas.
- A producer using
KafkaAvroSerializersends an incompatible schema: the Registry refuses to register it and the serializer throws on the producer side. - Brokers never read payloads, so they never reject anything because of a schema.
- The Registry stores schemas, not Avro data (data lives on the brokers).
- A consumer that meets a schema id missing from its cache fetches it from the Registry.
39. In Avro, what kind of evolution is adding a field without a default, and removing a field without a default?
Adding a field without a default is forward compatible; removing one without a default is backward compatible.
- Adding: consumers on the old schema can read new data (ignoring the unknown field); consumers on the new schema can’t read old data because the value is missing.
- Removing: consumers on the new schema can read old data (ignoring the extra field).
- With defaults, adding or removing is fully compatible, so always give new fields a default. The Registry’s default mode is
BACKWARD.
The wire format (magic byte, schema id) and a compatibility-mode table verified in code are in the serialization and Schema Registry post.
40. A JDBC source connector reads 3 tables with tasks.max=2 on a 3-worker cluster. How many tasks run?
Two: tasks = min(tasks.max, units of work) = min(2, 3).
The number of workers doesn’t decide the task count. Likewise an S3 sink reading a 2-partition topic has work for at most 2 tasks, even on a 10-broker cluster. In distributed mode, Connect stores configs, offsets and status in three internal topics (config.storage.topic, offset.storage.topic, status.storage.topic).
Exercises
Exercise 1: Verify three answers in a lab
Bring up the three-broker cluster from post 3. Verify: (a) question 23 (subscribe + assign); (b) question 17 (keyless records sent in a burst); (c) question 6 (a broker losing its data).
Solution to Exercise 1: my results
consumer.subscribe(List.of("orders"));
consumer.assign(List.of(new TopicPartition("orders", 0)));
// IllegalStateException: Subscription to topics, partitions and pattern are mutually exclusive
for (int i = 0; i < 30; i++) futures.add(producer.send(new ProducerRecord<>("orders", null, "x")));
// linger.ms=50 -> 30 null-key records sent in one burst -> partitions {0=30}
docker compose rm -sf kafka3 && docker compose up -d kafka3 # new container = empty disk
docker exec kafka1 kafka-topics --bootstrap-server kafka1:29092 --describe --topic orders
# after about 20 seconds: Isr: 1,2,3
For (c), the cp-kafka image runs kafka-storage format automatically when CLUSTER_ID is set; with plain Apache Kafka you have to format the directory yourself before the broker will start.
Exercise 2: Rewrite a ZooKeeper-era question
Rewrite “list under-replicated partitions with kafka-topics --zookeeper localhost:2181 --describe --under-replicated-partitions” for current Kafka, and say how to check the controller quorum’s state.
Solution to Exercise 2: KRaft commands and monitoring metrics
- Partitions:
kafka-topics --bootstrap-server localhost:9092 --describe --under-replicated-partitions(replicas outside the ISR) and--unavailable-partitions(no leader). - Quorum:
kafka-metadata-quorum --bootstrap-server localhost:9092 describe --status(leader, voters, follower lag) anddescribe --replication. - Monitoring: the
UnderReplicatedPartitions,OfflinePartitionsCountandActiveControllerCountmetrics.
Remember
- Translate a ZooKeeper-era answer (ACLs, dynamic config, controller election, CLI flags) to KRaft.
- Explain why
acks=all+ RF 3 + min ISR 2 survives one broker failure, and why min ISR never blocks reads. - Know when
auto.offset.resetis used, and which delivery guarantee committing before/after processing gives. - List the events that trigger a rebalance, and how to fix a consumer that exceeds
max.poll.interval.ms. - Know who rejects an incompatible schema, and whether adding/removing a field without a default is forward or backward compatible.
Interview questions
Junior
How do you prepare for CCDAK without dumps?
Learn from the official outline and docs, then verify each behaviour on a cluster running on your own machine.
Read the outline to know the scope, learn from the Apache Kafka and Confluent docs, try each behaviour (offset reset, rebalancing, acks when a broker dies), write your own questions per domain and review them repeatedly. If Confluent provides official sample questions, use them to get used to the format.
Why are so many Kafka exam-prep answers outdated?
Because many question banks were written when Kafka still used ZooKeeper, and Kafka 4.0 removed ZooKeeper entirely.
Questions on ACLs, dynamic configs, controller election and the CLI’s --zookeeper flag now have different answers: metadata lives in __cluster_metadata, managed by the KRaft controller quorum. Producer defaults also changed in 3.0 (acks=all, idempotence on).
Mid
Explain at-most-once, at-least-once and exactly-once on the consumer side.
Commit before processing is at-most-once, after processing is at-least-once; exactly-once exists only for Kafka → Kafka flows inside one transaction.
- At-most-once: a crash loses records.
- At-least-once: a crash means reprocessing, so processing must be idempotent.
- Exactly-once: read–process–write inside one Kafka transaction (Streams
exactly_once_v2). With external systems, use at-least-once plus deduplication, or store offsets in the same transaction as the results.
How do acks, min.insync.replicas and unclean leader election relate?
Together (typically all, 2 on RF 3, unclean disabled) they guarantee that an acknowledged record survives the loss of one broker.
acks=allwaits for every replica in the ISR.min.insync.replicassets the minimum ISR size for acceptingacks=allwrites.- Disabling unclean election makes sure only ISR replicas become leader.
Senior
What does KRaft change compared to ZooKeeper, operationally?
One system instead of two: no separate ZooKeeper ensemble to patch, monitor and secure, and faster controller failover.
Metadata is a log replicated with Raft and brokers receive changes as events, so clusters can handle more partitions. You need to plan the controller quorum (3 or 5 voters, ideally separate from brokers in production), monitor it with kafka-metadata-quorum, and migrate on 3.x before moving to 4.x.
What does a CCDAK certificate tell you when hiring a senior backend engineer?
It shows solid knowledge of Kafka’s APIs and semantics, not the ability to design.
The candidate knows offsets, delivery guarantees and replication; the certificate says nothing about deciding whether to use Kafka at all, choosing keys, handling failures, the outbox, operations and monitoring. In interviews I still ask a real scenario, e.g. design a consumer that updates balances without losing or double-applying anything.
Useful phrases for interviews
- “In the ZooKeeper era that lived in a znode; with KRaft it’s a record in the metadata log.”
- “
min.insync.replicasonly kicks in when the producer usesacks=all.” - “
auto.offset.resetis only consulted when the group has no valid committed offset.” - “Consumers can only read up to the high watermark, so
acks=1doesn’t make data visible any sooner.” - “Adding partitions breaks the key-to-partition mapping for new records; old records stay put.”
- “Exactly-once in Kafka Streams covers Kafka-to-Kafka flows, not side effects.”
- “Schema Registry rejects an incompatible schema; brokers never look at the payload.”
- “I verified the tricky answers on a local three-broker cluster instead of trusting a question bank.”
Notes based on the Advanced Backend course (Ronin Engineer), rewritten in my own words.