Let's Build 100k gRPC Streams | Distributed System in Kotlin

Name: Let's Build 100k gRPC Streams | Distributed System in Kotlin
Rating: 2.7 (2 reviews)

Create High-Performance Distributed Systems using Virtual Threads, Coroutines, Redis Pub/Sub & SSE

Created byChinmay Anand

Last updated 2/2025

English

What you'll learn

How to create a highly scalable gRPC server with Redis message broker
How to use SSE with gRPC server and Redis Message broker
How to use kotlin coroutines with Java 21 virtual threads for more efficiency
How a distributed server works with message broker and grpc server

Course content

5 sections • 16 lectures • 2h 29m total length

Introduction6:12
In this course i am going to explain this course in nutshell. In the last lecture i have attached the github link for the repository for backend code which is up to date.
Understand Sequence Diagram6:49
I am going to explain the sequence diagram in this lecture. Sequence diagram is very important before we start code. Thank you
Setting Up Kotlin Project in IntelliJ Idea2:47
In this section we are creating a fresh Kotlin project with spring web flux (reactive web dependency installed).

Installing dependencies for the project4:52
Install dependencies
In this lecture we are going to install all the required dependencies in this course, as we are using gradle build for your project we will be editing build.gradle.kts file.
Setting up Redis using Docker4:42
Setup redis
In this lecture we are going to setup our Redis using Docker. We will be adding a docker-compose.yml file and edit that file and then will check if you are redis is working or not.
Create Reactive Redis Config file7:23
Write redis config
In this lecture we are going to write config for reactive redis in our spring web flux project. Because we need to use it to push real time data to users using SSE.
Creating Controllers and Services3:59
Creating controller and service
In this lecture we are going to create controller and service folder and then will be adding required files in those folders.
Writing Proto file9:54
Write proto file
In this lecture we are going to write proto file so we can generate grpc code to work with.

StreamingServer Pt 123:42
In this lecture we are going to write Streaming server part 1, we will define the grpc server which is using Java 21 virtual threads and kotlin coroutines.
StreamingServer Pt 219:41
In this lecture we are going to write Streaming server part 2, we will define the grpc server which is using Java 21 virtual threads and kotlin coroutines.
Let's Start StreamingServer2:10
In this section we are going to start our streaming server which we have built using gRPC.
Let's Write the final file - Main file14:34
Resolve the Build the error and Run the Grpc Server1:51
In this lecture we are going to resolve the build error we have encountered when were trying to run the server.

Requirements

Basic knowledge of Java programming language

Description

What you'll learn

Dive deep into modern distributed systems development with this comprehensive course that combines cutting-edge technologies to build scalable, real-time applications. Learn how to harness the power of Kotlin and Spring Boot while leveraging the latest features like Virtual Thread Pools and Coroutines for optimal performance.

This project-based course guides you through building a production-grade notification system from the ground up. You'll master:

Advanced gRPC implementation in Kotlin with Spring Boot
Reactive programming using Spring WebFlux for non-blocking operations
Kotlin Coroutines for efficient asynchronous programming
Java 21 Virtual Thread Pools for improved scalability
Redis Pub/Sub for distributed message broadcasting
Server-Sent Events (SSE) for real-time client notifications
Docker containerization for seamless deployment
Distributed system architecture patterns and best practices

Starting with architecture design, you'll progress through implementation details, testing strategies, and deployment considerations. Each concept is explained thoroughly with real-world examples and best practices.

The course offers:

Hands-on coding sessions with step-by-step explanations
Deep dives into performance optimization techniques
Real-world scenarios and problem-solving approaches
Best practices for production deployment
Complete source code access and documentation

By the end of this course, you'll have built a high-performance, distributed notification system capable of handling thousands of concurrent connections. You'll understand how to combine Virtual Thread Pools with Coroutines for maximum efficiency, implement reactive programming patterns, and create scalable microservices.

In the last lecture of the course I have attached the github link for the backend code so you can clone it and try to improve it even further

This course is perfect for developers looking to master modern backend development with Kotlin and Spring. Whether you're a senior developer wanting to stay current with the latest technologies or a mid-level developer ready to advance your career, this course provides the perfect blend of theory and practical implementation.

Prerequisites:

Basic knowledge of Kotlin
Familiarity with Spring Framework
Understanding of REST APIs
Basic knowledge of microservices concepts

Who this course is for:

Beginner to advance Java and Kotlin programmers

Let's Build 100k gRPC Streams | Distributed System in Kotlin

What you'll learn

Explore related topics

Course content

Introduction3 lectures • 16min

Setting Up Wireframe5 lectures • 31min

Writing Controller and Service2 lectures • 29min

Creating StreamingServer5 lectures • 1hr 2min

Testing Streaming server with Grpc Client Code1 lecture • 12min

Requirements

Description

Who this course is for: