Are Apache Kafka Replica Followers Synchronous or Asynchronous?
A detailed look at how Apache Kafka replication works compared with its commit semantics, clarifying how ISR followers differ from Confluent observers.
Do Apache Kafka follower replicas replicate synchronously or asynchronously?
The question seems straightforward, yet it’s one of those Kafka subjects where various sources frequently seem to say opposite things. Plenty of Kafka trainings, certification courses and introductory explanations state that Kafka replication is asynchronous. Meanwhile, the Confluent Platform documentation on Multi-Region Clusters and multi-data-center architectures refers to synchronous and asynchronous replicas. In the terminology of replica placement, replicas are sync replicas, whereas observers are async replicas.
So which answer is correct?
In short: it depends on what you mean
From the perspective of the low-level replication mechanism, Kafka followers replicate by fetching data from the leader. They may lag behind, drop out of the ISR, and catch up again later. Seen this way, it makes sense that people call Kafka follower replication asynchronous.
From the perspective of Kafka’s commit and durability semantics, followers belonging to the in-sync replica set, or ISR, sit on the synchronous write path whenever producers use acks=all. A message counts as committed only once the ISR requirements are met. Seen this way, Kafka followers in the ISR are synchronous replicas.
This distinction matters all the more in Confluent Platform stretched cluster and 2.5 data center architectures, where the terminology is spelled out: regular replicas are synchronous replicas, and observers are asynchronous replicas by default.
The source of the confusion
The confusion typically arises because one word, synchronous, is used to answer two separate questions:
- How is data physically replicated between brokers?
- At what point is a write treated as committed or acknowledged?
Replication mechanics: why Kafka looks asynchronous
Looking at the first question, Kafka replication appears asynchronous. Followers pull records from the leader. The leader doesn’t push each record to each follower through a lock-step protocol in the style of two-phase commit. Followers can temporarily trail the leader. A follower may be alive yet not caught up enough. A follower can be dropped from the ISR and rejoin later, once it has caught up.
That’s why training materials frequently describe Kafka replication as asynchronous: they’re talking about how data is moved.
Commit semantics: why ISR followers are synchronous
The second question, however, leads to a different answer. Kafka’s own design documentation states that a message counts as committed only once every replica in that partition’s ISR has applied it to its log. The Kafka 4.3 documentation adds that consumers can see messages only after they’ve been replicated to all in-sync replicas and the min.insync.replicas condition has been satisfied. Refer to the Apache Kafka 4.3 docs on message delivery semantics and min.insync.replicas.
The accurate statement, then, isn’t just “Kafka followers are asynchronous” or “Kafka followers are synchronous”. It’s better put like this:
Mechanically, Kafka follower replication looks asynchronous, since followers fetch data and may lag, but when the producer uses
acks=all, ISR followers take part in synchronous commit semantics.
What really happens during a Kafka write
Every topic partition in Kafka has a single leader replica and zero or more follower replicas. Producers write to the leader, which determines the order of records in the partition log. Followers replicate the leader’s log.
In simplified form, the write path goes like this:
- A producer sends a produce request to the leader of the partition.
- The leader appends the records to its own local log.
- Follower replicas fetch the records from the leader.
- Kafka keeps track of which replicas are caught up enough; together they make up the ISR.
- Once the ISR-based commit requirements are met, the high watermark moves forward.
- Consumers read committed records only.
- With
acks=all, the producer gets a successful acknowledgement only once the write has met the ISR requirements.
The key point is that assigned replicas don’t all play the same role at all times. A follower within the ISR contributes to the durability guarantee. A follower outside the ISR remains a replica, but it no longer takes part in the current commit decision.
That’s where min.insync.replicas comes in. According to the Kafka 4.3 broker configuration documentation, min.insync.replicas defines the minimum number of in-sync replicas, the leader included, needed for a write to succeed when the producer sets acks=all or acks=-1. It further states that, with acks=all, all current ISR members have to acknowledge a write before it’s deemed successful. Refer to min.insync.replicas in the Kafka 4.3 broker configs.
Consider, for instance, a topic configured with:
replication.factor=3
min.insync.replicas=2
producer acks=all
When the ISR contains enough replicas, Kafka can acknowledge the write once the ISR rules are met. When the ISR drops below min.insync.replicas, the producer gets an error rather than a successful acknowledgement. This is the durability/availability trade-off governed by acks and min.insync.replicas.
Why followers are often called asynchronous
Followers are commonly described as asynchronous because Kafka doesn’t demand that every assigned replica be fully up to date at every moment.
A number of facts back up this view:
- Followers fetch data from the leader.
- Followers may fall behind the leader.
- Followers that aren’t caught up enough can be dropped from the ISR.
- Followers can catch up later and rejoin the ISR.
- Producers may choose weaker acknowledgement modes, such as
acks=1, in which the leader acknowledges after its local write without waiting for followers to replicate the data.
Seen from this angle, the statement “Kafka replication is asynchronous” is reasonable – it describes how replication works mechanically.
That statement turns misleading, though, if it leaves out the ISR and producer acknowledgements. With acks=all, an in-sync follower isn’t merely a passive copy kept in the background. It’s part of the condition that has to be met before the producer gets a successful acknowledgement and before the record becomes visible as committed data.
To put it precisely:
Kafka followers aren’t synchronous in the sense of physical replication in perfect lock-step. They are synchronous in the sense that, for
acks=allwrites, ISR followers belong to the commit path.
Why Confluent 2.5 DC documentation calls followers synchronous
Confluent Platform Multi-Region Clusters make the terminology easier to understand.
Confluent adds a third kind of replica, the observer. Traditionally, Kafka had leaders and followers; Multi-Region Clusters introduce observers on top of that. Observers don’t join the ISR by default, but, like followers, they try to keep pace with the leader.
Here’s the crucial difference:
- A regular replica within the ISR is a synchronous replica.
- An observer is, by default, an asynchronous replica.
According to Confluent’s documentation, observers make asynchronous replication possible because, by default, they stay out of the ISR. The leader doesn’t have to wait for observers before acknowledging the request to the producer. See the Observers section in Confluent’s docs.
The same terms are used in replica placement. The replicas field holds the constraints for sync replicas, and the observers field holds the constraints for async replicas. One of Confluent’s examples describes a topic with three sync replicas in one rack and two observers in a different rack. A producer using acks=all gets an acknowledgement once the sync replicas have replicated the message; the observers replicate the data too, but the leader doesn’t wait for them.
This is why Confluent materials may describe followers as synchronous and observers as asynchronous. They aren’t saying that followers never fall behind. They’re categorizing replicas according to whether they normally take part in the ISR-based acknowledgement path.
The 2.5 data center stretched cluster context
In Confluent Platform, a stretched 2.5 data center architecture consists of two fully functional data centers and one lightweight, or “0.5”, data center.
Both full data centers host Confluent Server nodes configured as brokers and controllers. The lightweight third site hosts a subset of KRaft controller nodes to keep the controller quorum. It isn’t a full data center with broker capacity equal to that of the other two sites.
For this architecture, Confluent describes RPO as dependent on configuration. According to the documentation, reaching RPO=0 requires replicas in at least two data centers, and min.insync.replicas has to exceed the number of replicas in any single data center. The documentation also points out that producers have to use acks=all for this to work. Refer to the Confluent Platform docs on Stretched Cluster 2.5 Data Center.
In this context, the word “synchronous” becomes critical for the business. If a write may be acknowledged only once enough replicas in different data centers have persisted it, those replicas are synchronous as far as RPO=0 is concerned. The cluster relies on ISR-based commit semantics to guarantee that a successful write survives the loss of an entire data center.
Observers can still be valuable in this architecture, particularly with automatic observer promotion. By default, however, observers aren’t in the ISR and aren’t part of the regular producer acknowledgement path. They offer an asynchronous copy that can assist in failover and recovery scenarios without imposing the same latency cost on every write.
Summary
So, do Apache Kafka followers replicate synchronously or asynchronously?
The most accurate answer is:
In terms of replication mechanics, Kafka followers are asynchronous, but in terms of the commit semantics of
acks=allwrites, ISR followers are synchronous.
That resolves the seeming contradiction between popular Kafka training materials and the Confluent Multi-Region Cluster documentation.
Training materials frequently say “asynchronous” because followers fetch from the leader, may fall behind, and may catch up later. That’s a statement about how replication physically takes place.
The Confluent documentation calls replicas synchronous and observers asynchronous because it classifies replicas by whether they take part in the ISR-based acknowledgement path. That’s a statement about commit semantics and multi-region durability.
In a regular Kafka cluster, the essential term is ISR. In a Confluent Multi-Region Cluster, the essential distinction is replica vs observer.
To sum it up briefly:
Kafka’s replication mechanism is pull-based and may exhibit lag, which is why it’s frequently called asynchronous. Yet when producers use
acks=all, in-sync follower replicas belong to Kafka’s synchronous commit path. That’s why, in Confluent stretched cluster and 2.5 DC architectures, followers are regarded as synchronous replicas and observers as asynchronous replicas.
Documentation links
- Apache Kafka 4.3: Design - Message Delivery Semantics
- Apache Kafka 4.3:
min.insync.replicasbroker config - Confluent Platform: Overview of Multi-DC deployment solutions
- Confluent Platform: Configure Multi-Region Clusters
- Confluent Platform: Observers
- Confluent Platform: Replica placement
- Confluent Platform: Multi-Data Center Architectures
- Confluent Platform: Stretched Cluster 2.5 Data Center