How does message ordering work in Kafka?

Question

Accepted Answer

Kafka guarantees **ordering within a partition** but **not across partitions** — a crucial concept. To get ordering for related events, you route them to the same partition (via the same key). Understanding ordering is important for correctness.

## Per-partition ordering

```text
Kafka guarantees:
  ✓ ORDER WITHIN a partition → events in a partition are strictly ordered (by offset);
    consumers read them in order
  ✗ NO order ACROSS partitions → events in different partitions have no relative order
    guarantee (they're processed in parallel by different consumers)
→ this is a FUNDAMENTAL Kafka property (and a common source of misunderstanding)
```

## Getting ordering for related events

```text
To keep RELATED events ordered → send them to the SAME partition:
  → use the SAME KEY for related events (key → hash → same partition):
    e.g. all events for orderId=5 use key=5 → same partition → ordered for that order
  → so per-entity ordering: key by the entity (userId, orderId, accountId)
→ choose the key so events that must be ordered share a partition
```

## Trade-offs and considerations

```text
⚠️ Ordering vs PARALLELISM → ordering within a key/partition limits parallelism for that key
  (all of one key's events are processed by one consumer, in order)
⚠️ A few things break ordering: producer retries (without idempotence + max.in.flight=1),
  adding partitions (changes key→partition mapping)
→ if you DON'T need ordering → no key (spread freely for max parallelism)
→ if you NEED ordering → key appropriately; accept the parallelism scope
```

## Why it matters

Understanding message ordering in Kafka is valuable because **ordering is a fundamental, commonly-misunderstood Kafka concept** important for correctness, so it's essential knowledge.

Kafka's ordering guarantee is specific and crucial to understand.

Understanding **per-partition ordering** — that Kafka guarantees order **within a partition** (events strictly ordered by offset, read in order) but **not across partitions** (events in different partitions having no relative order, processed in parallel) — is a fundamental Kafka property and a **common source of misunderstanding** (people often wrongly assume global ordering), so understanding it correctly is essential for correctness.

Understanding how to **get ordering for related events** — sending them to the same partition by using the **same key** (so related events like all events for a specific order or user, keyed by that entity, go to the same partition and stay ordered) — is the key practical technique for achieving the ordering correctness applications need (per-entity ordering via keying).

Understanding the **trade-offs and considerations** — that ordering within a key/partition **limits parallelism** for that key (all of one key's events processed by one consumer in order), that a few things break ordering (producer retries without idempotence and max.in.flight=1, adding partitions changing key mapping), and that you should use no key when ordering isn't needed (for maximum parallelism) but key appropriately when it is (accepting the parallelism scope) — reflects the nuanced understanding needed to design for correct ordering while balancing parallelism.

This ordering knowledge is important because getting it wrong (assuming global ordering, or not keying events that need ordering) causes real correctness bugs.

Since ordering is a fundamental, commonly-misunderstood Kafka concept (per-partition only, requiring keys for related-event ordering) important for correctness, and since understanding the guarantee, how to achieve ordering via keys, and the trade-offs (ordering vs parallelism) is essential, understanding message ordering in Kafka is valuable, essential Kafka knowledge — a fundamental, often-misunderstood concept crucial for correctness, where understanding per-partition ordering and key-based routing for related events (and the parallelism trade-off) is necessary to design Kafka systems that order events correctly, a key concept every Kafka user must understand accurately.