Skip to main content
CF

Apache Kafka Series - Kafka Streams for Data Processing

4h 50m 7s
English
Paid
Updated September 2026

Apache Kafka Series - Kafka Streams for Data Processing is a 71-lesson 4 hours 50 minutes self-paced course by Udemy. Taught by Stephane Maarek, whose Apache Kafka Series has reached more than 40,000 students, this course goes deep on the Kafka Streams API specifically — how it works, and how to use it in production Java 8 applications.

Course facts

Lessons
71
Duration
4 hours 50 minutes
Level
All levels
Language
English
Updated
2026-09-11
Instructor
Udemy
Price
Premium

Taught by Stephane Maarek, whose Apache Kafka Series has reached more than 40,000 students, this course goes deep on the Kafka Streams API specifically — how it works, and how to use it in production Java 8 applications.

How the course builds up

  • A first WordCount application to get Kafka Streams running end to end
  • Packaging, building and scaling a real Kafka Streams application
  • Stateless and stateful operations in the KStream and KTable APIs
  • Practice projects, including a Favourite Colour app with a Scala variant and a Bank Balance app for testing Exactly Once Semantics
  • Configuring and understanding Exactly Once Semantics in depth
  • Testing a Kafka Streams topology properly

It's aimed at developers, DevOps engineers and architects who already have a solid grip on Apache Kafka and are comfortable in Java 8 or Scala, and want to add one of the most in-demand stream-processing libraries to their toolkit.

Who teaches Apache Kafka Series - Kafka Streams for Data Processing? Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

What lessons are included in Apache Kafka Series - Kafka Streams for Data Processing?

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 71 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: What is Kafka Streams?
All Course Lessons (71)
#Lesson TitleDurationAccess
1
What is Kafka Streams? Demo
04:48
2
Course Objective / Prerequisites / Target Students
04:12
3
About your Instructor: Stephane Maarek
02:21
4
Running your first Kafka Streams Application: WordCount
12:53
5
Kafka Streams vs other stream processing libraries (Spark Streaming, NiFI, Flink
03:02
6
Section Objective
01:46
7
Kafka Streams Core Concepts
03:29
8
Environment and IDE Setup: Java 8, Maven, IntelliJ IDEA
04:04
9
Starter Project Setup
07:58
10
Kafka Streams Application Properties
07:26
11
Java 8 Lambda Functions - quick overview
02:56
12
Word Count Application Topology
14:09
13
Printing the Kafka Streams Topology
01:34
14
Kafka Streams Graceful Shutdown
02:04
15
Running Application from IntelliJ IDEA
09:23
16
Debugging Application from IntelliJ IDEA
04:07
17
Internal Topics for our Kafka Streams Application
03:48
18
Packaging the application as Fat Jar & Running the Fat Jar
04:35
19
Scaling our Application
04:00
20
Section Wrap-Up
01:41
21
Section Objectives
01:15
22
KStream & KTables
03:40
23
Stateless vs Stateful Operations
01:42
24
MapValues / Map
01:36
25
Filter / FilterNot
01:23
26
FlatMapValues / FlatMap
02:11
27
Branch
02:46
28
SelectKey
01:15
29
Reading from Kafka
02:17
30
Writing to Kafka
01:53
31
Streams Marked for Re-Partition
02:53
32
Refresher on Log Compaction
17:46
33
KStream and KTables Duality
02:21
34
Transforming a KTable to a KStream
00:42
35
Transforming a KStream to a KTable
01:25
36
Section Summary
00:48
37
FavouriteColour - Practice Exercise Description & Guidance
03:21
38
Stuck? Here are some Hints!
02:41
39
Java Solution
08:34
40
Running the application
05:47
41
Scala Solution
06:21
42
Section Objective
01:01
43
KTable groupBy
01:47
44
KGroupedStream / KGroupedTable Count
02:06
45
KGroupedStream / KGroupedTable Aggregate
04:13
46
KGroupedStream / KGroupedTable Reduce
01:41
47
KStream peek
02:09
48
KStream Transform / TransformValues
01:13
49
What if I want to write to an external System?
01:41
50
Summary Diagram
01:04
51
What's Exactly Once?
06:08
52
Exactly Once in Kafka 0.11
02:42
53
What's the problem with at least once anyway?
01:30
54
How to do exactly once in Kafka Streams
02:05
55
BankBalance - Exercise Overview
02:16
56
Kafka Producer Guidance
01:42
57
Kafka Producer Solution
14:18
58
Kafka Streams Guidance & Hints
01:56
59
Kafka Streams Solution
09:13
60
Running the BankBalance Application
04:43
61
Section Summary
00:57
62
What are joins in Kafka Streams?
02:50
63
Join Constraints and GlobalKTables
02:54
64
The different types of joins: Inner Join, Left Join, Outer Join
02:46
65
Creating a join with UserEnrich Kafka Streams App
12:34
66
Running the Kafka Streams Join application
05:08
67
Testing in Kafka Streams
04:03
68
Setup your Kafka Streams project
03:59
69
Hands-On: Test your WordCount application
14:29
70
Congratulations and next steps
02:33
71
THANK YOU!
01:33
Unlock unlimited learning

Get instant access to all 70 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

What courses are similar to Apache Kafka Series - Kafka Streams for Data Processing?

More courses by Udemy

Frequently asked questions

What prerequisites are required for this course?
The course requires a basic understanding of Java 8, as it involves writing Kafka Streams applications in Java. Familiarity with Maven and IntelliJ IDEA is also necessary as these tools are used for environment setup and running applications. Prior experience with stream processing concepts or libraries is beneficial but not mandatory.
What types of applications will I learn to build in this course?
Students will build four Kafka Streams applications, including a WordCount application. The course covers building and packaging these applications, emphasizing practical implementation using Java 8. You will also explore different operations with KStream and KTable APIs and learn to manage dependencies and scale applications.
Who is the target audience for this course?
This course is intended for software developers and data engineers interested in mastering data processing with Kafka Streams. It's suitable for those who want practical experience with Kafka Streams applications and wish to understand the theoretical concepts behind stream processing on Apache Kafka.
How does this course compare to other stream processing libraries?
The course provides a comparison between Kafka Streams and other stream processing libraries like Spark Streaming, NiFi, and Flink. It highlights the unique features and advantages of Kafka Streams, particularly its use of Java and its DSL for high-level stream processing operations, setting it apart from other libraries.
What specific tools and platforms are used in this course?
The course uses Java 8 for programming, Maven for dependency management, and IntelliJ IDEA for development. These tools are essential for setting up the environment and running Kafka Streams applications. The course also covers Java 8 Lambda Functions and packaging applications as Fat JARs for deployment.
What topics are not covered in this course?
While the course focuses on Kafka Streams, it does not cover other aspects of Apache Kafka, such as Kafka Connect, Kafka Producer, or Kafka Consumer in depth. It also doesn't dive into non-Java programming languages beyond offering a Scala solution for one exercise.
How much time should I expect to commit to this course?
With a total of 71 lessons, the course is designed to balance theoretical knowledge and practical exercises. Although the exact runtime is unspecified, students should prepare to spend a significant amount of time on hands-on practice, especially for building and testing Kafka Streams applications.