~2 msMessage delivery at the network throughput limit

tln/dayThe cluster scales to thousands of brokers and petabytes of data

80%+ F100Share of the world's largest companies using Kafka

7 tln/dayMessage volume in LinkedIn's production Kafka cluster

Integrations

Change one system without rewriting the rest

The integration layer cures four ailments of rigid data exchange: data loss, cascading rework, source overload and inconsistency. ESB, Kafka and n8n solve different problems.

50flows in 6 months — a speed benchmark for an ESB project

48flows in production with a target loosely coupled architecture

16xfaster launch of standard integrations compared to code

ESB

Routing, transformation, guaranteed delivery and low-code support of legacy exchanges.

Kafka

Durable log: an event is stored, re-read, multiple consumers read at their own pace.

n8n

Fast orchestration of a process and AI steps where heavy event streaming isn't needed.

sourcedata contractESB/Kafka/n8nmonitoringconsumers

Related Sections

ESB approach Kafka n8n Integration cases Apache Kafka News

Sources

Enterprise Integration Patterns Martin Fowler: Event-Driven Confluent: Kafka vs ESB

Industry solutions

What you can do with Apache Kafka

All solutions

E-commerce and retail A single order event stream that triggers warehouse reservation, payment, and delivery Order processing: eliminates stock mismatches and manual reconciliation between the storefront, warehouse, and ERPLearn more →Finance and banking Streaming processing of transactions and account events with replay for auditing Real-time operations monitoring and antifraud: millisecond responses instead of batch reconciliationLearn more →Manufacturing and IoT Collecting sensor telemetry into an event log with threshold triggers Equipment monitoring: predictive maintenance instead of reacting after downtime occursLearn more →Logistics and transportation Shipment tracking and status events available to all systems through the bus Supply chain tracking: a single order status without polling adjacent systemsLearn more →Telecom Streaming network and billing events for real-time pricing and alerts Network monitoring and billing: real-time stream processing instead of nightly batchesLearn more →Media and content A user event bus (clicks, views) for personalization Recommendations and behavior analytics: a near-real-time profile instead of delayed exportsLearn more →B2B distribution Event-driven integration of PIM, ERP, and partner storefronts through a single broker Catalog and pricing sync: a change is published once and distributed to all consumersLearn more →Healthcare Event exchange between HIS, laboratories, and the patient portal Patient data coordination: results are available to adjacent systems without direct integrationsLearn more →

Capabilities

Apache Kafka Capabilities

Before: ERP↔CRM↔Warehouse↔Storefront↔Payments↔Analytics - an N×N tangle of direct connectionsEvery change requires updating several integrations at onceA failure in one system cascades through synchronous chainsAfter: all systems publish/read events through the Kafka busThe producer does not know the consumers, and the consumer can withstand a neighbor outageA new consumer (ML, reporting) connects to the stream without changing the sources

Comparison diagram with two panels. Left ('Before: point-to-point') shows 5-6 systems (ERP, CRM, warehouse, storefront, payments, analytics) connected by many crossing straight arrows forming a tangled web (N×N links, each brittle and requiring changes when modified). Right ('After: an event bus on Kafka') shows the same systems, each linked by one arrow to a central horizontal Kafka bus: producers publish events from above, consumers subscribe from below. Labels emphasize: left - coupling, manual synchronization, cascading failures; right - loose coupling, async, fault tolerance, decoupling, and adding new consumers without changing sources.

An event bus instead of point-to-point

One event stream instead of N×N direct integrations: adding a new system does not require touching the others

Loose coupling

Services are changed, replaced, and scaled independently - a release in one system does not break adjacent ones

Asynchronous processing

Peak loads are smoothed by the event buffer: the storefront does not go down when the warehouse or payment system responds slowly

Fault tolerance and replay

Events are stored in a durable log: a failed consumer catches up after recovery without data loss

Horizontal scaling

Rising load is handled by adding brokers and partitions without reworking the architecture

Real-time streams

Data becomes available to adjacent systems in milliseconds - orders, stock, and prices sync almost instantly

A single event log as the source of truth

New consumers (analytics, ML, reporting) connect to the existing stream without loading the source systems

Integration portability

Event contracts and a standard broker let you hand support over to another team or contractor without rewriting anything

Approach

How we implement Apache Kafka

Without modifying the core

We do not fork or patch the Apache Kafka core. Apache Kafka stays on the standard upgradable version, while business logic is moved into separate microservices nearby, so platform updates do not break your customizations.

International Standards, Not Homegrown Hacks

Where a mature international solution exists, we use it instead of inventing our own protocol or platform. Before writing code, we study how the problem is already solved in the industry.

Transferability

The solution is loosely coupled and documented: it can be handed over between teams and contractors without rewriting. You are not tied to us.

AI compatibility

Apache Kafka in the AI stack

Data stream for ML and real-time analytics

A single event log is a ready-made source for feature engineering, streaming scoring, and near-real-time marts without loading production systems.

A bus for AI agents

Kafka's pub/sub model gives agents a loosely coupled channel for exchanging events: one agent publishes a result, others react without knowing about each other.

Event sourcing for reproducibility

A durable log and replay let you replay event history for model retraining and AI decision auditing.

Event-triggered pipelines

A new event (order, request, stock change) automatically triggers inference or an agent workflow without polling systems.

News

What's new in Apache Kafka

All news

2026-06-25
Kafka 4.3.1: bugfix release, Kafka Streams RocksDB memory leak fix
A patch release after 4.3.0. The main fix is a RocksDB native memory leak in Kafka Streams; other critical bugs have been closed.
2026-05-22
Kafka 4.3.0: broker cordoning, tiered storage improvements, deprecation classic rebalance protocol
25 KIPs, 600+ commits since 4.2.0. New: broker cordoning before removal from the cluster, partition size metrics, share group tuning, tiered storage improvements. Phase 1 of deprecating the consumer's classic rebalance protocol has begun.
2026-02-21
Kafka 3.9.2: bug fix plus a security patch for the legacy 3.9.x branch
35 issues fixed since 3.9.1, including security patches. KIP-1252 removes the behavior mismatch of AlterConfigPolicy between ZooKeeper and KRaft modes (an optional compatibility flag).
2026-02-17
Kafka 4.2.0: share groups (queues, KIP-932) are production-ready, and the new Streams rebalance protocol has moved out of preview
38 KIPs. Share groups (native queues on top of topics, KIP-932) are production-ready; the new Kafka Streams rebalance protocol (KIP-848) is production-ready too. DLQ support has been added in Streams exception handlers (KIP-1034), along with Java 25 support.

ESB platforms (MuleSoft, Talend) have had built-in queue semantics and DLQ for decades; Kafka as a top-level queue over topics (share groups) reached production only in 4.2.0 (2026). MuleSoft →DLQ and error routing have been standard ESB features since the beginning; Kafka Streams only received DLQ support in exception handlers (KIP-1034) in this release. Talend ESB →

Blog

Articles about Apache Kafka

All articles

Apache Kafka: an event bus for integration

Apache Kafka and ESB in a Loosely Coupled Architecture: How to Reduce Costs, Guarantee Delivery, and Ensure Data Integrity in the IT Systems of Large Enterprises

Learn more