🌊 Streaming Data Language
0 / 25 completed
1 / 25
A Kafka architect explains: "The topic has 12 partitions with a replication factor of 3."
What does a replication factor of 3 mean?
Replication factor = number of broker copies of each partition:
| Role | Function |
|---|---|
| Leader | Handles all reads and writes for the partition |
| Followers | Replicate leader data; promote on leader failure |
Minimum recommended: RF=3 for production. RF=3 tolerates up to 2 broker failures. Key vocabulary: leader partition, follower replication, ISR (In-Sync Replicas), unclean leader election, acks=all for durability.
2 / 25
A team has two consumer instances in the same consumer group reading from a 6-partition topic.
How are partitions assigned?
Consumer group = cooperative partition consumption — each partition is consumed by exactly one consumer in the group:
| Scenario | Assignment |
|---|---|
| 6 partitions, 2 consumers | 3 partitions each |
| 6 partitions, 6 consumers | 1 partition each (max parallelism) |
| 6 partitions, 8 consumers | 2 consumers sit idle |
Key vocabulary: consumer group rebalance, partition assignment, lag monitoring, committed offset, at-least-once vs. exactly-once.
3 / 25
A monitoring alert fires: "The consumer group is at 45,000 messages lag on partition 3."
What does consumer lag indicate?
Consumer lag = latest_offset − committed_offset
| Lag situation | Likely cause |
|---|---|
| Sudden large lag spike | Consumer crash, temporary partition reassignment |
| Slowly growing lag | Consumer throughput below producer rate |
| Stable lag | Consumer keeping pace but behind (acceptable in some systems) |
Key vocabulary: consumer lag, offset commit, lag monitoring (Kafka UI, Burrow), backpressure, lag recovery rate.
4 / 25
An engineer explains: "The streaming pipeline uses event-time windowing rather than processing-time windowing."
What is the key difference?
Event-time vs. processing-time windowing:
| Time domain | Based on | Challenge |
|---|---|---|
| Event-time | Timestamp embedded in the event payload | Late/out-of-order events require watermarks |
| Processing-time | Wall-clock time when event arrives at processor | Inaccurate for events delayed in transit |
Key vocabulary: watermark, late data handling, allowed lateness, window trigger, tumbling vs. sliding vs. session window.
5 / 25
A system design document states: "The pipeline guarantees exactly-once delivery semantics."
What does exactly-once semantics mean and why is it hard to achieve?
Delivery guarantees — the fundamental trade-off in distributed messaging:
| Guarantee | Trade-off | Implementation |
|---|---|---|
| At-most-once | May lose messages, no duplicates | Fire and forget |
| At-least-once | No loss, may duplicate | Retry on failure |
| Exactly-once | No loss, no duplicates (hardest) | Idempotent producer + transactional API |
Key vocabulary: idempotent producer, transactional API, 2PC in streaming, semantic guarantee trade-offs, Flink checkpointing.
6 / 25
Sarah: 'Okay team, I've deployed the new Kafka consumer. We're seeing a lot of errors related to out-of-order messages in our analytics dashboard. The logs show that some consumers are receiving messages before others, despite running on the same cluster and consuming from the same topic.'
Which of the following best explains Sarah's observation regarding message order in Kafka?Sarah's observation points to a fundamental characteristic of Kafka's distributed architecture. Because Kafka brokers replicate data across multiple nodes asynchronously, there's no guarantee that all consumers will receive the same message at exactly the same time. This inherent delay and asynchronous commit process can result in messages being processed out of order; it is not a bug but rather a consequence of how Kafka handles fault tolerance and scalability. Option A describes a symptom, not the root cause. Options C and D are incorrect because they attribute the issue to consumer configuration or topic settings respectively – while these *can* contribute to ordering issues, they aren't the primary driver.7 / 25
David: 'Hey team, I've just updated the Kafka producer to use a higher batch size. We should see an improvement in throughput!'
Maria: 'I'm seeing some increased latency on our dashboards since the update. The consumer group is struggling to keep up with the incoming data volume.'
Which of the following best describes the potential root cause of Maria's observation, given David's change?
Incorrect options often assume direct causation or focus on unrelated problems. The core issue here is related to Kafka's producer-consumer model and how batching affects message ordering. A larger batch size from the producer increases the likelihood of messages being processed in a non-sequential order by consumers, as they are grouped together before delivery. This creates contention for the consumer group, causing latency as consumers must resequence messages – not a failure of the cluster or a reduction in partitions.
8 / 25
{
"status_code": 500,
"message": "Internal Server Error",
"details": {
"error_type": "KafkaUnavailableException",
"topic": "user_events",
"partition": 3}
}
}
This API response indicates a
500 Internal Server Error, specifically a KafkaUnavailableException. This strongly suggests that the consumer application cannot communicate with one or more of the Kafka brokers hosting the user_events topic and partition 3. The other options represent alternative causes, such as replication issues, misconfiguration, or data format errors – but this response directly points to a connectivity problem which is the most likely reason for a 500 status code in this scenario.9 / 25
PR Description:
**Subject:** Kafka Consumer Performance Degradation - User Events Topic
**Description:** Following the recent update to the Kafka producer batch size (increased from 1000 to 5000), we've observed increased latency and potential out-of-order messages in our analytics dashboards. The consumer group responsible for processing `user_events` is struggling to keep pace with the higher data volume, leading to increased lag on key partitions. We are investigating potential bottlenecks within the consumption pipeline.
Can you help me understand what might be causing this performance degradation?The correct answer (option 1) addresses the most likely root cause given the producer's batch size increase. Increasing the batch size dramatically increases the volume of data produced, which can overwhelm consumers if they are not adequately configured to handle this higher throughput. Options 2, 3 and 4 represent other potential issues but aren't directly related to the change in the producer configuration; a simple scaling operation is a reasonable first step to address the increased load, while network latency or disk I/O would require more specialized investigation.
10 / 25
During a code review for the Kafka consumer service, John mentions: 'We're batching producer requests to improve throughput. We've increased the batch size from 1000 to 5000. Maria reports increased latency and potential out-of-order messages on the `user_events` topic.' Considering this scenario, which of the following is the MOST likely explanation for Maria's observation?
Context: Increased batch sizes can lead to a higher volume of data being produced at once. If the consumer group isn't adequately scaled or if processing resources are limited, this increased rate can overwhelm the system, leading to delays and potentially out-of-order message handling.
Context: Increased batch sizes can lead to a higher volume of data being produced at once. If the consumer group isn't adequately scaled or if processing resources are limited, this increased rate can overwhelm the system, leading to delays and potentially out-of-order message handling.
The correct answer (option 2) reflects a core principle of streaming systems – increased throughput can overwhelm processing resources. While network issues or bugs *could* contribute, the scenario explicitly states an increase in batch size and Maria's subsequent report of latency and out-of-order messages strongly points to the consumer group being unable to keep pace with the higher data volume. Options 1 & 3 are plausible but not the most immediate explanation given the provided context; option 4 is too specific and doesn't align with a typical producer configuration change.
11 / 25
Sarah: 'Okay team, I've deployed the new Kafka consumer. We're seeing a lot of errors related to out-of-order messages in our analytics dashboard. The logs show that some consumers are receiving messages before others, despite running on the same cluster and consuming from the same topic.'
Which of the following best explains Sarah's observation regarding message order in Kafka?Sarah's observation points to a fundamental characteristic of Kafka's distributed architecture. Because Kafka brokers replicate data across multiple nodes asynchronously, there's no guarantee that all consumers will receive the same message at exactly the same time. This inherent delay and asynchronous commit process can result in messages being processed out of order; it is not a bug but rather a consequence of how Kafka handles fault tolerance and scalability. Option A describes a symptom, not the root cause. Options C and D are incorrect because they attribute the issue to consumer configuration or topic settings respectively – while these *can* contribute to ordering issues, they aren't the primary driver.12 / 25
David: 'Hey team, I've just updated the Kafka producer to use a higher batch size. We should see an improvement in throughput!'
Maria: 'I'm seeing some increased latency on our dashboards since the update. The consumer group is struggling to keep up with the incoming data volume.'
Which of the following best describes the potential root cause of Maria's observation, given David's change?
Incorrect options often assume direct causation or focus on unrelated problems. The core issue here is related to Kafka's producer-consumer model and how batching affects message ordering. A larger batch size from the producer increases the likelihood of messages being processed in a non-sequential order by consumers, as they are grouped together before delivery. This creates contention for the consumer group, causing latency as consumers must resequence messages – not a failure of the cluster or a reduction in partitions.
13 / 25
{
"status_code": 500,
"message": "Internal Server Error",
"details": {
"error_type": "KafkaUnavailableException",
"topic": "user_events",
"partition": 3}
}
}
This API response indicates a
500 Internal Server Error, specifically a KafkaUnavailableException. This strongly suggests that the consumer application cannot communicate with one or more of the Kafka brokers hosting the user_events topic and partition 3. The other options represent alternative causes, such as replication issues, misconfiguration, or data format errors – but this response directly points to a connectivity problem which is the most likely reason for a 500 status code in this scenario.14 / 25
PR Description:
**Subject:** Kafka Consumer Performance Degradation - User Events Topic
**Description:** Following the recent update to the Kafka producer batch size (increased from 1000 to 5000), we've observed increased latency and potential out-of-order messages in our analytics dashboards. The consumer group responsible for processing `user_events` is struggling to keep pace with the higher data volume, leading to increased lag on key partitions. We are investigating potential bottlenecks within the consumption pipeline.
Can you help me understand what might be causing this performance degradation?The correct answer (option 1) addresses the most likely root cause given the producer's batch size increase. Increasing the batch size dramatically increases the volume of data produced, which can overwhelm consumers if they are not adequately configured to handle this higher throughput. Options 2, 3 and 4 represent other potential issues but aren't directly related to the change in the producer configuration; a simple scaling operation is a reasonable first step to address the increased load, while network latency or disk I/O would require more specialized investigation.
15 / 25
During a code review for the Kafka consumer service, John mentions: 'We're batching producer requests to improve throughput. We've increased the batch size from 1000 to 5000. Maria reports increased latency and potential out-of-order messages on the `user_events` topic.' Considering this scenario, which of the following is the MOST likely explanation for Maria's observation?
Context: Increased batch sizes can lead to a higher volume of data being produced at once. If the consumer group isn't adequately scaled or if processing resources are limited, this increased rate can overwhelm the system, leading to delays and potentially out-of-order message handling.
Context: Increased batch sizes can lead to a higher volume of data being produced at once. If the consumer group isn't adequately scaled or if processing resources are limited, this increased rate can overwhelm the system, leading to delays and potentially out-of-order message handling.
The correct answer (option 2) reflects a core principle of streaming systems – increased throughput can overwhelm processing resources. While network issues or bugs *could* contribute, the scenario explicitly states an increase in batch size and Maria's subsequent report of latency and out-of-order messages strongly points to the consumer group being unable to keep pace with the higher data volume. Options 1 & 3 are plausible but not the most immediate explanation given the provided context; option 4 is too specific and doesn't align with a typical producer configuration change.
16 / 25
Sarah: 'Okay team, I've deployed the new Kafka consumer. We're seeing a lot of errors related to out-of-order messages in our analytics dashboard. The logs show that some consumers are receiving messages before others, despite running on the same cluster and consuming from the same topic.'
Which of the following best explains Sarah's observation regarding message order in Kafka?Sarah's observation points to a fundamental characteristic of Kafka's distributed architecture. Because Kafka brokers replicate data across multiple nodes asynchronously, there's no guarantee that all consumers will receive the same message at exactly the same time. This inherent delay and asynchronous commit process can result in messages being processed out of order; it is not a bug but rather a consequence of how Kafka handles fault tolerance and scalability. Option A describes a symptom, not the root cause. Options C and D are incorrect because they attribute the issue to consumer configuration or topic settings respectively – while these *can* contribute to ordering issues, they aren't the primary driver.17 / 25
David: 'Hey team, I've just updated the Kafka producer to use a higher batch size. We should see an improvement in throughput!'
Maria: 'I'm seeing some increased latency on our dashboards since the update. The consumer group is struggling to keep up with the incoming data volume.'
Which of the following best describes the potential root cause of Maria's observation, given David's change?
Incorrect options often assume direct causation or focus on unrelated problems. The core issue here is related to Kafka's producer-consumer model and how batching affects message ordering. A larger batch size from the producer increases the likelihood of messages being processed in a non-sequential order by consumers, as they are grouped together before delivery. This creates contention for the consumer group, causing latency as consumers must resequence messages – not a failure of the cluster or a reduction in partitions.
18 / 25
{
"status_code": 500,
"message": "Internal Server Error",
"details": {
"error_type": "KafkaUnavailableException",
"topic": "user_events",
"partition": 3}
}
}
This API response indicates a
500 Internal Server Error, specifically a KafkaUnavailableException. This strongly suggests that the consumer application cannot communicate with one or more of the Kafka brokers hosting the user_events topic and partition 3. The other options represent alternative causes, such as replication issues, misconfiguration, or data format errors – but this response directly points to a connectivity problem which is the most likely reason for a 500 status code in this scenario.19 / 25
PR Description:
**Subject:** Kafka Consumer Performance Degradation - User Events Topic
**Description:** Following the recent update to the Kafka producer batch size (increased from 1000 to 5000), we've observed increased latency and potential out-of-order messages in our analytics dashboards. The consumer group responsible for processing `user_events` is struggling to keep pace with the higher data volume, leading to increased lag on key partitions. We are investigating potential bottlenecks within the consumption pipeline.
Can you help me understand what might be causing this performance degradation?The correct answer (option 1) addresses the most likely root cause given the producer's batch size increase. Increasing the batch size dramatically increases the volume of data produced, which can overwhelm consumers if they are not adequately configured to handle this higher throughput. Options 2, 3 and 4 represent other potential issues but aren't directly related to the change in the producer configuration; a simple scaling operation is a reasonable first step to address the increased load, while network latency or disk I/O would require more specialized investigation.
20 / 25
During a code review for the Kafka consumer service, John mentions: 'We're batching producer requests to improve throughput. We've increased the batch size from 1000 to 5000. Maria reports increased latency and potential out-of-order messages on the `user_events` topic.' Considering this scenario, which of the following is the MOST likely explanation for Maria's observation?
Context: Increased batch sizes can lead to a higher volume of data being produced at once. If the consumer group isn't adequately scaled or if processing resources are limited, this increased rate can overwhelm the system, leading to delays and potentially out-of-order message handling.
Context: Increased batch sizes can lead to a higher volume of data being produced at once. If the consumer group isn't adequately scaled or if processing resources are limited, this increased rate can overwhelm the system, leading to delays and potentially out-of-order message handling.
The correct answer (option 2) reflects a core principle of streaming systems – increased throughput can overwhelm processing resources. While network issues or bugs *could* contribute, the scenario explicitly states an increase in batch size and Maria's subsequent report of latency and out-of-order messages strongly points to the consumer group being unable to keep pace with the higher data volume. Options 1 & 3 are plausible but not the most immediate explanation given the provided context; option 4 is too specific and doesn't align with a typical producer configuration change.
21 / 25
Sarah: 'Okay team, I've deployed the new Kafka consumer. We're seeing a lot of errors related to out-of-order messages in our analytics dashboard. The logs show that some consumers are receiving messages before others, despite running on the same cluster and consuming from the same topic.'
Which of the following best explains Sarah's observation regarding message order in Kafka?Sarah's observation points to a fundamental characteristic of Kafka's distributed architecture. Because Kafka brokers replicate data across multiple nodes asynchronously, there's no guarantee that all consumers will receive the same message at exactly the same time. This inherent delay and asynchronous commit process can result in messages being processed out of order; it is not a bug but rather a consequence of how Kafka handles fault tolerance and scalability. Option A describes a symptom, not the root cause. Options C and D are incorrect because they attribute the issue to consumer configuration or topic settings respectively – while these *can* contribute to ordering issues, they aren't the primary driver.22 / 25
David: 'Hey team, I've just updated the Kafka producer to use a higher batch size. We should see an improvement in throughput!'
Maria: 'I'm seeing some increased latency on our dashboards since the update. The consumer group is struggling to keep up with the incoming data volume.'
Which of the following best describes the potential root cause of Maria's observation, given David's change?
Incorrect options often assume direct causation or focus on unrelated problems. The core issue here is related to Kafka's producer-consumer model and how batching affects message ordering. A larger batch size from the producer increases the likelihood of messages being processed in a non-sequential order by consumers, as they are grouped together before delivery. This creates contention for the consumer group, causing latency as consumers must resequence messages – not a failure of the cluster or a reduction in partitions.
23 / 25
{
"status_code": 500,
"message": "Internal Server Error",
"details": {
"error_type": "KafkaUnavailableException",
"topic": "user_events",
"partition": 3}
}
}
This API response indicates a
500 Internal Server Error, specifically a KafkaUnavailableException. This strongly suggests that the consumer application cannot communicate with one or more of the Kafka brokers hosting the user_events topic and partition 3. The other options represent alternative causes, such as replication issues, misconfiguration, or data format errors – but this response directly points to a connectivity problem which is the most likely reason for a 500 status code in this scenario.24 / 25
PR Description:
**Subject:** Kafka Consumer Performance Degradation - User Events Topic
**Description:** Following the recent update to the Kafka producer batch size (increased from 1000 to 5000), we've observed increased latency and potential out-of-order messages in our analytics dashboards. The consumer group responsible for processing `user_events` is struggling to keep pace with the higher data volume, leading to increased lag on key partitions. We are investigating potential bottlenecks within the consumption pipeline.
Can you help me understand what might be causing this performance degradation?The correct answer (option 1) addresses the most likely root cause given the producer's batch size increase. Increasing the batch size dramatically increases the volume of data produced, which can overwhelm consumers if they are not adequately configured to handle this higher throughput. Options 2, 3 and 4 represent other potential issues but aren't directly related to the change in the producer configuration; a simple scaling operation is a reasonable first step to address the increased load, while network latency or disk I/O would require more specialized investigation.
25 / 25
During a code review for the Kafka consumer service, John mentions: 'We're batching producer requests to improve throughput. We've increased the batch size from 1000 to 5000. Maria reports increased latency and potential out-of-order messages on the `user_events` topic.' Considering this scenario, which of the following is the MOST likely explanation for Maria's observation?
Context: Increased batch sizes can lead to a higher volume of data being produced at once. If the consumer group isn't adequately scaled or if processing resources are limited, this increased rate can overwhelm the system, leading to delays and potentially out-of-order message handling.
Context: Increased batch sizes can lead to a higher volume of data being produced at once. If the consumer group isn't adequately scaled or if processing resources are limited, this increased rate can overwhelm the system, leading to delays and potentially out-of-order message handling.
The correct answer (option 2) reflects a core principle of streaming systems – increased throughput can overwhelm processing resources. While network issues or bugs *could* contribute, the scenario explicitly states an increase in batch size and Maria's subsequent report of latency and out-of-order messages strongly points to the consumer group being unable to keep pace with the higher data volume. Options 1 & 3 are plausible but not the most immediate explanation given the provided context; option 4 is too specific and doesn't align with a typical producer configuration change.
Frequently Asked Questions
What does the "Streaming Data Language" exercise practise?
Practice English for Apache Kafka: replication factor, consumer groups, consumer lag, event-time windowing, and exactly-once semantics vocabulary for data engineers.
How many questions are in this exercise?
This exercise has 25 questions, each multiple-choice with a full explanation shown after you answer.
What English level is this exercise for?
This exercise is tagged Intermediate. If the vocabulary feels difficult, browse the Data Engineering Language category page for an easier module to start with.
Is this exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is free with no account, sign-up, or paywall.
Do I get feedback if I answer incorrectly?
Yes — whichever option you choose, right or wrong, you'll immediately see an explanation clarifying the correct term and why the other options don't fit.
Can I retry this exercise?
Yes — once you finish all the questions, a "Try again" button on the results screen resets the exercise so you can practise as many times as you like.
Do I need an account to track my progress?
No account is required. Your progress bar and score for this session are tracked in the browser as you go, but nothing is saved once you leave the page.
Is "Streaming Data Language" part of a larger series?
Yes — it's one exercise in the Data Engineering Language category on CoderSlingo. See the category page for the full list of related exercises on similar terminology.
Can I link directly to this exercise?
Yes — this exercise has its own permanent URL, so you can bookmark it or share the link directly with a colleague or study partner.
Where can I find more exercises like this one?
See the Data Engineering Language category page for related exercises, or browse the main Exercises hub for other IT English topics.