Custom SerDes in Kafka - Time & Space Complexity

Time Complexity: Custom SerDes

O(n)

Understanding Time Complexity

When using custom SerDes in Kafka, it is important to understand how the time to serialize and deserialize data grows as the data size increases.

We want to know how the processing time changes when the input data gets bigger.

Scenario Under Consideration

Analyze the time complexity of the following custom SerDes code snippet.

public class CustomSerdes implements Serializer<MyObject>, Deserializer<MyObject> {

  @Override
  public byte[] serialize(String topic, MyObject data) {
    // Convert object fields to bytes
    return data.toByteArray();
  }

  @Override
  public MyObject deserialize(String topic, byte[] bytes) {
    // Convert bytes back to object
    return MyObject.fromByteArray(bytes);
  }
}

This code converts an object to bytes and back, handling serialization and deserialization for Kafka messages.

Identify Repeating Operations

Look at what happens inside serialize and deserialize methods.

• Primary operation: Processing each field of the object to convert to or from bytes.
• How many times: Once for each field or element inside the object, depending on its size.

How Execution Grows With Input

As the size of the object grows (more fields or larger data), the time to serialize or deserialize grows proportionally.

Input Size (n)	Approx. Operations
10 fields	10 steps to process all fields
100 fields	100 steps to process all fields
1000 fields	1000 steps to process all fields

Pattern observation: The work grows directly with the number of fields or data size.

Final Time Complexity

Time Complexity: O(n)

This means the time to serialize or deserialize grows linearly with the size of the data.

Common Mistake

[X] Wrong: "Serialization time stays the same no matter how big the data is."

[OK] Correct: Because serialization must process every part of the data, bigger data means more work and more time.

Interview Connect

Understanding how serialization time grows helps you design efficient data pipelines and shows you can think about performance in real systems.

Self-Check

"What if the object contains nested objects? How would that affect the time complexity of serialization and deserialization?"