Producer throughput optimization in Kafka - Time & Space Complexity

Time Complexity: Producer throughput optimization

O(n)

Understanding Time Complexity

When sending messages with a Kafka producer, we want to know how the time to send grows as we increase the number of messages.

We ask: How does the producer's work change when we send more messages?

Scenario Under Consideration

Analyze the time complexity of the following Kafka producer code snippet.

Properties props = new Properties();
props.put("bootstrap.servers", "localhost:9092");
props.put("acks", "all");
props.put("batch.size", 16384);
props.put("linger.ms", 5);
KafkaProducer<String, String> producer = new KafkaProducer<>(props);

for (int i = 0; i < n; i++) {
    producer.send(new ProducerRecord<>("topic", Integer.toString(i), "message" + i));
}
producer.close();

This code sends n messages to a Kafka topic using batching and a small delay to improve throughput.

Identify Repeating Operations

Look at what repeats as n grows.

• Primary operation: Sending each message inside the loop.
• How many times: Exactly n times, once per message.
• Batching groups messages before sending, but the loop still runs n times.

How Execution Grows With Input

As you send more messages, the number of send calls grows directly with n.

Input Size (n)	Approx. Operations
10	10 send calls
100	100 send calls
1000	1000 send calls

Pattern observation: The work grows in a straight line as you add more messages.

Final Time Complexity

Time Complexity: O(n)

This means the time to send messages grows directly with the number of messages you send.

Common Mistake

[X] Wrong: "Batching means sending 1000 messages takes the same time as sending 10."

[OK] Correct: Batching reduces network calls but you still process each message once, so time still grows with the number of messages.

Interview Connect

Understanding how sending more messages affects time helps you design efficient producers and explain your choices clearly in real projects.

Self-Check

"What if we increased the batch size to a very large number? How would the time complexity change?"