Data and Communication Patterns
Create reliable and scalable applications faster
Design Your Microservices with Confidence!
Microservices make it much easier to implement and understand a single service. But they also introduce new problems. You now have a system of independent services that need to interact with each other but do not depend on each other. Suddenly, exchanging data between services and orchestrating complex business operations becomes a complicated process.
As a consultant and trainer, I have worked with developers in various companies. Sooner or later, all of them struggle with this new, often unexpected complexity.
But what makes communication between microservices so tricky?
In a monolithic application, we implemented complex use cases by calling methods in various parts of our application. Now we split and distribute the functionality over multiple services. Instead of calling a method, we now need to call a remote service.
Sure, we try to design our services so that we minimize the number of calls to other services. But we can't avoid them entirely. So, we need reliable and scalable communication between our services.
Exchanging data is much harder than it seems
The main challenges, when exchanging data between services, are to avoid scalability issues and to ensure data consistency. The tools that we used in monolithic applications no longer provide the right solutions for that. With them, you need to choose between scalability and data consistency.
Distributed transactions are a typical example of that. They ensure consistency, but they rely on locks, which create scalability issues. That's why a lot of modern data stores no longer support them.
Some teams, therefore, decide to use multiple local transactions. This is called a dual write, and you should avoid it at all costs. It might be easy to implement and provide great scalability, but it puts data consistency at risk.
That's where a lot of developers get stuck. The old patterns are no longer good enough. But that doesn't mean that you can't build a scalable and reliable system of microservices.
New patterns and tools to ensure consistency and scalability
Over the last few years, our industry has developed new patterns and tools to solve these issues. These new patterns enable you to get scalability and data consistency at the same time. I've helped lots of teams to apply these patterns in their microservices. After a quick introduction and a few examples, they were able to easily solve one of their biggest struggles:
Communication between their services.
And they were finally able to reap the benefits of a microservices architecture. They focused on the business logic of each service and no longer worried about communication between them.
In this course, I want to offer you the same learning experience. We will start with the essential requirements and communication concepts for microservices. Then we will take a look at synchronous and event-based approaches to sharing data between services, compare different options to ensure consistency during distributed update operations, and take a look at event-focussed strategies to manage your data.
Create reliable and scalable applications
Having completed this course, you will be well prepared to design and implement robust and scalable microservice applications.
Instead of hoping that everything goes well and that none of your services fail, you will be able to use modern patterns that were developed for scalable and highly-distributed microservices. You will know how to design your services and the communication between them to ensure data consistency, robustness, and scalability.
Your new skills will not only improve the way you write software. They will also establish you as a true expert within your team. With your expertise on modern software development, you will be well-prepared to take on new, interesting tasks and to grow your technical career.
Join now to get a structured, in-depth introduction to the new patterns specifically designed for microservices.
Hear What the Alumni Have To Say
I teach the course material as a self-paced online course and as an in-person workshop, and every time I get fantastic feedback.
But don't just take my word for it. Here is what other people say:
This course has helped me earn new responsibilities!
I have learned way more than I expected, each topic explains the concept very well and helped me to understand it easily. My favorite one was the outbox pattern using Debezium.
Having the projects to go along with the lecture helped reinforce the learning and made me really understand how each pattern is working.
I would recommend this course to anyone interested in improving their knowledge of new microservice patterns. This course has helped me earn new responsibilities.
Tyler Karol // Java Developer
I recommend it for all seasoned architects
This workshop provides you with a good foundation on techniques and architectural options for microservices and gives you a solid understanding of their benefits and drawbacks. Thorben focusses on really problematic topics that are often ignored during conference talks, e.g., data synchronization/consistency and error handling. These problems are often complicated and require tailored solutions for the selected architecture.
I especially liked the coding exercises with provided solutions. I worked on them during and after the workshop, and I learned a lot. I also enjoyed the detailed discussions about data consistency in a distributed microservice architecture.
I would also recommend this workshop to seasoned architects and I even organized an additional in-house workshop with Thorben as I was very satisfied after participating.
Anders Malmborg // Principal Architect
Now It's Your Turn!
When you enroll in the Data and Communication Patterns for Microservices course today, you’ll get access to my self-paced video course that teaches you all you need to know about modern patterns for microservices so that you can:
To make the course content easier to consume, I've split it into 9 blocks that I will release weekly. But don't worry, you don't need to follow a fixed schedule. You get lifetime access to all of the training materials so that you can watch and re-watch the lectures whenever you want.
And you are 100% safe when trying this out. That’s all I’m suggesting. Just try the Data and Communication Patterns for Microservices course for 30 days to see if it works for you.
If it does, you'll learn when and how to use each of the modern patterns developed for microservice architectures. This will make your daily work more enjoyable and prepare you for the next step in your career - and I think that's exactly what's about to happen. If for some reason, you're not happy with the course or if you are still not sure how to use some of the explained patterns, then just let me know within the first 30 days that you want to use my Simple & Unconditional 100% Money-Back Guarantee and you'll get 100% of your money back.
The Data and Communication Patterns course consists of 8 modules with 20 lectures with example projects and exercises that show you everything you need to know to ensure data consistency and scalability for your microservice application.
You also get free access to a set of exclusive bonuses that improve your training experience and ensure your long-term success.
But first, let's take a look at the modules and lectures included in the Data and Communication Patterns course.
Learn about the differences between monoliths and microservices and their effect on your persistence layer.
- Lecture 1:
Requirements of microservices
- Lecture 2:
Bounded context and why it's not enough
- Lecture 3:
Transaction models to ensure data consistency
Synchronous service calls look like an easy solution, but implementing them reliably is harder than it seems.
- Lecture 4:
API composition based on synchronous service calls
- Lecture 5:
Prevent failure cascading
- Lecture 6:
Find other services in a dynamically scaled environment
- Lecture 7:
Simplify the implementation of your client services
You can avoid synchronous service calls by storing all required information locally.
- Lecture 8:
Store the required data in a view database
Standard solutions for asynchronous communication between your services are based on events.
- Lecture 9:
- Lecture 10:
Create domain events to replicate your data
Publishing an event without using a distributed transaction requires new patterns and tools.
- Lecture 11:
- Lecture 12:
Change Data Capture with Debezium
- Lecture 13:
Implementing the outbox pattern using Debezium
If you need to update multiple services, eventual consistency scales much better than global transactions.
- Lecture 14:
- Lecture 15:
Choreography-based SAGA pattern
- Lecture 16:
Orchestration-based SAGA pattern
- Lecture 17:
Anomalies of the SAGA pattern
Instead of using a relational table model, you might want to store your events in an event store.
- Lecture 18:
- Lecture 19:
Event sourcing vs. event-based architectures
If we're talking about event sourcing, we also need to talk about CQRS:
- Lecture 20:
Sign Up Today To Get These Free Bonuses
Course Features For Your Success
To make this course as effective and flexible as possible, all classes provide you with lifetime access to all of the training videos, example projects, exercises with solutions and all other course materials.
Learn modern patterns in 8 chapters with 20 engaging video lectures.
Get all of the example projects that are used during the course.
Study at your own pace with lifetime access to all training material.
Try what you have learned in practical exercises.
(Certification Class only)
Get a comprehensive handout with commented slides.
(Certification Class only)
Certificate of Completion
Earn a certificate of completion to prove your expertise.
(Certification Class only)
Data and Communication Patterns
You have a choice to make: Do what you’ve been doing or try something new.
You know the problems you're dealing with. Do you really want to keep worrying about inconsistencies and scalability issues over and over again?
Take a new direction, and get a new result. Start using the new patterns and tools that have been developed to ensure scalability and data consistency in a microservice architecture.
Simple & Unconditional 100% Money-Back Guarantee
This is more than just a guarantee. It's a promise from a developer (me) to a developer (you).
Take 30 days to study the Data and Communication Patterns for Microservices course and learn how to use new patterns and tools to build scalable and consistent microservices.
If you're not happy with the course or if you are still not sure how to use some of the explained features, send me an email and ask for a refund. After you have logged in, you will find my email address at the bottom of the course page. I will promptly send you 100% of your money back.
Yes, that's right. I'm taking all the risk with this guarantee. You could rip me off by enrolling in the Data and Communication Patterns for Microservices course with the intention requesting your money back after 30 days.
But I trust that you won't do that. We software developers are honest people and don't rip each other off, right?
So, I trust you, and you don't have to take any risks.
Here are answers to some frequently asked questions:
Yes, of course, we will!
I will show you several implementations of the patterns during the lectures and you will get all code samples.
And while you're working on the exercises, you will extend existing services and implement your own microservices.
We use different open source frameworks that provide ready-to-use implementations of most of the explained patterns.
You can use these frameworks with Spring Boot, Eclipse Microprofile and plain Java SE. During the workshop, I will use Spring Boot to implement the services.
You should be familiar with Java, of course ;-) and have at least some basic knowledge of dependency injection, REST APIs and JPA.
Sure, here is one of the lecture included in the course.
You get life-time access to all lectures, example projects, exercises, handouts and bonuses.
This is a self-paced video course. You don't have to follow any schedule. You decide yourself when you want to start, how much time you can invest and if you're going to take a break for your summer vacation.
Some students spend 1-2 hours each week, others go through multiple weeks of content in 1 day. Both options are totally fine. Do whatever fits your professional and private schedule.