Let's Build 100k gRPC Streams

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

What's inside

Learning objectives

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

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

Syllabus

Introduction

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.

I am going to explain the sequence diagram in this lecture. Sequence diagram is very important before we start code. Thank you

In this section we are creating a fresh Kotlin project with spring web flux (reactive web dependency installed).

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.

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.

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 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.

Write proto file

In this lecture we are going to write proto file so we can generate grpc code to work with.

Write message broker

In this lecture we are going to we are going to write message broker file for redis.

In this lecture we are going to write controllers which can be used to manually publish the messages and get the SSE stream.

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.

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.

In this section we are going to start our streaming server which we have built using gRPC.

In this lecture we are going to resolve the build error we have encountered when were trying to run the server.

Traffic lights

Read about what's good

what should give you pause

and possible dealbreakers

Combines Kotlin, Spring Boot, Virtual Thread Pools, and Coroutines, which are valuable for building scalable and real-time applications

Covers distributed system architecture patterns and best practices, which are essential for designing robust and scalable systems

Requires familiarity with Spring Framework and REST APIs, which may exclude some beginner-level developers

Teaches Redis Pub/Sub and Server-Sent Events (SSE), which are useful for implementing real-time client notifications

Employs Java 21 Virtual Thread Pools for improved scalability, which is a relatively new technology

Focuses on advanced gRPC implementation in Kotlin with Spring Boot, which is a valuable skill for building microservices

Reviews summary

Build scalable distributed systems in kotlin

According to students, this course offers a highly practical, project-based approach to building a scalable distributed system using Kotlin, Spring Boot/WebFlux, gRPC, Redis, Java 21 Virtual Threads, and Coroutines. Learners appreciate the opportunity to build a real-world notification system and gain insights into modern backend development. While the course is generally well-received, some reviewers noted that the prerequisites might be steeper than listed and that the pace can be fast in certain sections.

Focuses on building architecture, less on load testing.

"The course shows *how* to build it for scale, but didn't see a detailed load test to 100k."

"The focus is strongly on the architecture and code implementation, not on performance testing details."

"Left wondering about the practical steps and proof for achieving the '100k concurrent connections' claim."

Complete backend code provided via GitHub.

"Having the full source code on GitHub was incredibly helpful for following along."

"Could refer to the repository when stuck on implementation details."

"Appreciated the access to the complete, working final project code."

Covers relevant, current JVM ecosystem tech.

"Loved learning about Virtual Threads and Coroutines together in a practical context."

"Great practical intro to gRPC with Kotlin/Spring and modern Java features."

"The combination of technologies felt very current and relevant for today's backend systems."

"Exploring Java 21 Virtual Threads with Kotlin Coroutines was a key highlight for me."

Builds a real, hands-on distributed system.

"Building the notification system end-to-end was the best part."

"I could immediately see how to apply this to my work after completing the project."

"The hands-on coding sessions helped solidify the concepts more than just theory would."

"This is a great practical example of building a complex distributed service."

Explanations can be quick or lack depth.

"Had to pause and rewatch lectures multiple times to grasp some parts fully."

"Wish there were deeper dives into certain configurations or architectural choices."

"Some sections felt rushed, assuming a quick understanding of complex topics."

"The instructor moves quite quickly through some core concepts."

Requires solid existing Kotlin/Spring knowledge.

"Felt a bit lost without a stronger Spring WebFlux background coming in."

"Basic Kotlin might not be enough; be comfortable with intermediate concepts and syntax."

"Came in with just basic Spring and found it challenging at times to keep up."

"This course is definitely for those already comfortable with the Spring ecosystem."

Activities

Be better prepared before your course. Deepen your understanding during and after it. Supplement your coursework and achieve mastery of the topics covered in Let's Build 100k gRPC Streams | Distributed System in Kotlin with these activities:

Review Kotlin Coroutines

Show steps

Strengthen your understanding of Kotlin Coroutines to better grasp the asynchronous programming concepts used in the course.

Browse courses on Kotlin Coroutines

Show steps

Read the official Kotlin Coroutines documentation.
Work through a Kotlin Coroutines tutorial.
Write small programs using coroutines.

Brush up on Spring WebFlux

Show steps

Review Spring WebFlux concepts to prepare for the reactive programming aspects of the gRPC streaming server.

Browse courses on Spring Webflux

Show steps

Review the Spring WebFlux documentation.
Study examples of reactive controllers and services.
Practice building simple reactive endpoints.

Read 'Reactive Spring'

Show steps

Deepen your understanding of reactive programming with Spring to enhance your ability to build scalable gRPC streams.

View Spring 6 Recipes: A Problem-Solution Approach... on Amazon

Show steps

Read the book 'Reactive Spring'.
Take notes on key concepts and examples.
Try out the code samples provided in the book.

Four other activities

Expand to see all activities and additional details

Show all seven activities

Implement gRPC services

Show steps

Practice implementing gRPC services in Kotlin to solidify your understanding of the core concepts.

Show steps

Define a simple gRPC service using Protocol Buffers.
Implement the service in Kotlin using Spring Boot.
Test the service using a gRPC client.

Write a blog post on Virtual Threads

Show steps

Solidify your understanding of Java 21 Virtual Threads by explaining the concept in a blog post.

Show steps

Research Java 21 Virtual Threads.
Write a blog post explaining the benefits and use cases.
Publish the blog post on a platform like Medium.

Extend the Notification System

Show steps

Enhance the notification system built in the course by adding new features or improving existing ones.

Show steps

Identify areas for improvement in the existing system.
Implement new features, such as user authentication or message persistence.
Test the extended system thoroughly.

Contribute to a gRPC Kotlin project

Show steps

Contribute to an open-source gRPC project written in Kotlin to gain practical experience and learn from others.

Show steps

Find an open-source gRPC Kotlin project on GitHub.
Identify an issue to work on or propose a new feature.
Submit a pull request with your changes.

Career center

Learners who complete Let's Build 100k gRPC Streams | Distributed System in Kotlin will develop knowledge and skills that may be useful to these careers:

Real Time Application Developer

A Real Time Application Developer creates applications that process and display data with minimal delay. This course, focusing on building scalable, real-time applications with Kotlin and Spring Boot, is directly relevant. Real Time Application Developers must leverage technologies like gRPC, Redis Pub/Sub, and Server-Sent Events (SSE) and this course provides hands-on experience with these technologies. This course helps a Real Time Application Developer build efficient and responsive systems. This course is a strong fit for anyone pursuing this career.

See salaries and explore the career path for Real Time Application Developer

Backend Engineer

A Backend Engineer focuses on server-side logic, databases, and application programming interfaces to ensure applications run smoothly. This course concentrating on Kotlin, Spring Boot, gRPC, Redis, and SSE directly aligns with the responsibilities of a Backend Engineer. A Backend Engineer builds scalable and efficient systems, and this course provides hands-on experience building a real-time notification system. The course emphasizing reactive programming with Spring WebFlux, Kotlin Coroutines, and Java 21 Virtual Thread Pools, helps a Backend Engineer to optimize application performance and handle thousands of concurrent connections. Learning the best practices for production deployment is useful when working as a Backend Engineer.

See salaries and explore the career path for Backend Engineer

Microservices Developer

A Microservices Developer specializes in designing, building, and deploying microservices. This course directly helps the skills of a Microservices Developer by providing hands-on experience with Kotlin, Spring Boot, gRPC, and Redis, all of which are frequently employed in microservices architectures. This course helps a Microservices Developer to handle thousands of concurrent connections by learning Reactive Programming patterns. The knowledge of Docker containerization for seamless deployment makes this course suitable for Microservices Developers seeking to create scalable microservices.

See salaries and explore the career path for Microservices Developer

Software Engineer

Software Engineers design, develop, and maintain software systems. This course focusing on building scalable, real-time applications is beneficial for a Software Engineer. The course provides practical experience with Kotlin, Spring Boot, gRPC, Redis, and SSE, which are relevant technologies for a Software Engineer. A Software Engineer builds high-performance distributed systems, and this course provides hands-on coding sessions with step-by-step explanations. The focus on performance optimization techniques and best practices for production deployment is valuable for any Software Engineer wanting to stay current with modern backend development.

See salaries and explore the career path for Software Engineer

Application Developer

This course builds a production-grade notification system, making it relevant for an Application Developer who builds various software applications. The course provides hands-on experience with Kotlin, Spring Boot, gRPC, Redis Pub/Sub, and SSE, which are technologies commonly used in application development. An Application Developer leverages reactive programming using Spring WebFlux and Kotlin Coroutines, key topics covered in this course. The focus on performance optimization techniques and best practices for production deployment makes this course useful for any Application Developer looking to enhance their skills in modern backend development.

See salaries and explore the career path for Application Developer

API Developer

An API Developer specializes in designing, developing, and maintaining application programming interfaces (APIs). This course is beneficial, as it provides hands-on experience with gRPC implementation in Kotlin with Spring Boot, which are used in modern API development. The course helps an API Developer build efficient and scalable APIs by teaching reactive programming using Spring WebFlux and Kotlin Coroutines. The distributed system architecture involving Redis Pub/Sub for message broadcasting is also crucial for building robust APIs. This course offers practical skills that an API Developer can immediately apply.

See salaries and explore the career path for API Developer

Software Architect

Software Architects are responsible for high-level design choices and technical standards. This course, focusing on building scalable and real-time distributed systems, directly benefits Software Architects looking to enhance their expertise. The course offers insights into designing efficient systems using technologies like Kotlin, Spring Boot, gRPC, and Redis. By diving into reactive programming, Kotlin Coroutines, and Java 21 Virtual Thread Pools, the course helps Software Architects make informed decisions for performance optimization. The practical approach, including hands-on coding sessions and real-world scenarios, is particularly helpful for a Software Architect.

See salaries and explore the career path for Software Architect

Distributed Systems Engineer

Distributed Systems Engineers specialize in designing, implementing, and managing distributed computing systems. This course, focusing on building distributed systems with Kotlin and Spring Boot, aligns with the work of Distributed Systems Engineers. A Distributed Systems Engineer should understand reactive programming, Kotlin Coroutines, and Java 21 Virtual Thread Pools. Learning the best practices for production deployment is also valuable. This course teaches real-world examples and best practices. This course provides foundational knowledge for this career.

See salaries and explore the career path for Distributed Systems Engineer

Solutions Architect

A Solutions Architect designs and oversees the implementation of complex software systems that meet specific business needs. This course focusing on distributed systems development with Kotlin and Spring Boot directly aligns with the skills required of a Solutions Architect. The course guides learners through architecture design, implementation details, testing strategies, and deployment considerations for a production-grade notification system. A Solutions Architect must understand distributed system architecture patterns, and this course provides hands-on experience with gRPC, Redis Pub/Sub, and SSE. This course provides a practical foundation for a career as a Solutions Architect.

See salaries and explore the career path for Solutions Architect

Platform Engineer

A Platform Engineer designs, builds, and maintains the infrastructure and tools that support software development and deployment. This course focusing on building scalable distributed systems with Kotlin and Spring Boot is valuable especially for the Platform Engineer. The course's coverage of Docker containerization, reactive programming, and performance optimization techniques helps a Platform Engineer ensure the reliability of systems. This course directly aligns with the responsibilities, as it covers Docker containerization and deployment strategies.

See salaries and explore the career path for Platform Engineer

Messaging Engineer

A Messaging Engineer focuses on the design, implementation, and maintenance of messaging systems, making this course highly relevant. This course emphasizing gRPC, Redis Pub/Sub, and Server-Sent Events (SSE) directly aligns with the technologies used by Messaging Engineers. They often work with distributed systems, this course provides practical experience in building such systems using Kotlin and Spring Boot. Understanding reactive programming, Kotlin Coroutines, and Java 21 Virtual Thread Pools is valuable for performance optimization in messaging applications. This course may solidify the skills of a Messaging Engineer.

See salaries and explore the career path for Messaging Engineer

Cloud Engineer

A Cloud Engineer implements, plans, and designs cloud-based systems, so this course is beneficial through its focus on building distributed systems with Kotlin and Spring Boot. This course directly aligns with the responsibilities of a Cloud Engineer as it covers Docker containerization and deployment strategies. Cloud Engineers benefit from understanding technologies like gRPC, Redis Pub/Sub, and Server-Sent Events (SSE). Learning how to optimize performance using Spring WebFlux, Kotlin Coroutines, and Java 21 Virtual Thread Pools is valuable when working with cloud infrastructure. This may provide foundational knowledge for a Cloud Engineer.

See salaries and explore the career path for Cloud Engineer

Performance Engineer

Performance Engineers focus on optimizing the performance of software systems. This course helps build a foundation in optimizing applications with Kotlin and Spring Boot, which is directly relevant to a Performance Engineer. The course covers performance optimization techniques using Spring WebFlux, Kotlin Coroutines, and Java 21 Virtual Thread Pools. A Performance Engineer may be interested in the hands-on coding sessions and real-world scenarios. Best practices for production deployment may also enhance the knowledge of a Performance Engineer.

See salaries and explore the career path for Performance Engineer

DevOps Engineer

A DevOps Engineer automates and streamlines software development and deployment processes. This course, with its focus on Docker containerization and best practices for production deployment, directly supports the role of a DevOps Engineer. The course helps a DevOps Engineer understand how to efficiently deploy and manage applications built with Kotlin, Spring Boot, gRPC, and Redis. Knowledge of distributed system architecture patterns and performance optimization techniques allows a DevOps Engineer to ensure the scalability and reliability of systems. This may be useful for a DevOps Engineer.

See salaries and explore the career path for DevOps Engineer

Systems Architect

Systems Architects work toward the creation of a blueprint for software systems. Because this course teaches distributed systems development with Kotlin and Spring Boot, it may align with the work Systems Architects do. A Systems Architect should understand architecture design, implementation details, testing strategies, and deployment considerations, as covered in this course. A Systems Architect should understand distributed system architecture patterns, and this course provides hands-on experience with gRPC, Redis Pub/Sub, and SSE.

See salaries and explore the career path for Systems Architect

Reading list

We've selected one books that we think will supplement your learning. Use these to develop background knowledge, enrich your coursework, and gain a deeper understanding of the topics covered in Let's Build 100k gRPC Streams | Distributed System in Kotlin.

Spring 6 Recipes

Save

Provides a comprehensive guide to reactive programming with Spring. It covers Spring WebFlux in detail, which is essential for understanding the non-blocking operations used in the course. While not strictly required, it offers valuable insights into building reactive applications with Spring and can serve as a useful reference.

Spring 6 Recipes: A Problem-Solution Approach to...

Paperback

Spring 6 Recipes: A Problem-Solution Approach to...

Kindle Edition

Distributed System in Kotlin

What's inside

Learning objectives

Syllabus

Traffic lights

Save this course

Reviews summary

Build scalable distributed systems in kotlin

Activities

Career center

Reading list

Share

Similar courses