Skip to main content
depth-first · source-traced · production-grade

Most Kafka courses stop where production begins.

Deep, correct courses on Java, Kafka and Flink — traced to the official docs, built on one continuous system you actually run. Not a hello-world producer and a wave goodbye.

35+
lessons, grouped
by topic
100+
illustrations
and sketches
0
prior Kafka
experience required
Java
plus the command line
and basic Docker
what you will learn

The judgment, not just the vocabulary.

By the end you can look at a Kafka diagram — or a production incident — and say what is happening underneath. That is the gap between engineers who use Kafka and engineers who are trusted to design it.

01

A partition strategy you can defend

Why brokers, topics, and partitions are shaped the way they are, and how the log stays both durable and fast. You choose a topic and partition plan for a workload instead of guessing.

02

Delivery guarantees, on purpose

Producers, acknowledgments, and offset management. You pick at-least-once or exactly-once because the problem asks for it, and you can say what throughput you gave up to get there.

03

Lag and rebalancing you can diagnose

One consumer, many consumers, and the rebalancing storm. You can read the failure, not just restart the group and hope.

04

Schemas that survive change

Avro and Protobuf with the Schema Registry, so a new field does not silently break every consumer that was already in production.

05

Streams, SQL, and Connect

Kafka Streams and ksqlDB for real-time pipelines without standing up a second cluster, and Kafka Connect for databases and data lakes without custom glue.

06

A cluster that stays healthy

Performance tuning, monitoring, and the operational patterns that keep a cluster upright under load — the work that starts after the first consumer compiles.

roadmap

The road into Kafka, then through it.

Two stages. Get the Java foundations under you, then walk the course in order. Nothing here assumes you have already run a broker.

before kafka prerequisites

What you should already be comfortable with

The course starts from first principles of Kafka. It does not reteach the language. A passing familiarity with distributed systems helps, and it is not required.

Java, or another JVM language required
Maven, so the labs build
The command line
Basic Docker, for a local cluster
Prior Kafka experience not required
Start with Learn Java →
inside the course 35+ lessons

The order the course is built in

Architecture first, then the clients, then the failure modes, then the tools you reach for once the mental model is solid. Each stage uses the one before it.

The log: brokers, topics, partitions
Producers, acks, offsets
Consumer groups and rebalancing core
Schemas and the Schema Registry
Kafka Streams, ksqlDB, Connect
Monitoring, tuning, cluster health
Open the course →
the whole course

Everything the Kafka course covers.

From producers and consumers to rebalancing storms and exactly-once semantics. Built on real failure scenarios. Spring Boot is used in the examples once the Kafka idea is already clear.

apache kafka course · free to start

Design it, build it, and keep it running

You will work with real producers and consumers, real partitioning decisions, and the same incidents that show up in production: broker loss, consumer lag, and a rebalance that will not settle.

Level: intermediate Prereq: Java, command line, Docker 35+ lessons Kafka Streams · Schema Registry · Connect

what the course walks through

01Brokers, topics, partitions, and the log
02Why that design is both durable and fast
03Producers, acknowledgments, delivery guarantees
04Consumers and offset management
05Consumer groups and rebalancing storms
06Avro, Protobuf, and the Schema Registry
07Exactly-once versus at-least-once
08Kafka Streams and ksqlDB
09Kafka Connect, without custom glue
10Tuning, monitoring, and a healthy cluster

what you leave able to do

  • Choose a topic and partition strategy for a real workload
  • Write producers and consumers with the guarantee the problem needs
  • Diagnose consumer lag and a bad rebalance
  • Build a streaming pipeline with Kafka Streams
  • Argue throughput against durability in a design review
who it is for

If Kafka keeps showing up in the design meeting.

You do not need to already be a Kafka person. You need to be willing to build the model from the ground up.

backend

Platform and backend engineers

You keep hearing “we should use Kafka” and you want to know what that sentence actually commits you to.

architects

People weighing event-driven systems

Microservices, fintech, or a data platform — and a need to tell when Kafka’s trade-offs fit the problem.

interviews

System design prep

Kafka shows up as the building block. You want to talk about it as a design choice, not a buzzword.

Gopi Gorantala
Staff Engineer · Solution Architect
Apache Kafka at ING Bank, Brussels
Course author on Educative.io

The outcome I want from this course is simple. The next time someone says “let’s just add Kafka,” you are the person who asks what problem it is actually solving, and whether the trade-offs fit — then helps design the answer.

Code samples fade. That architectural instinct does not. Most of the examples use Java and Spring Boot, after the Kafka idea is already clear.

Apache Kafka Kafka Streams Schema Registry Java Spring Boot Event-driven architecture