Data and Communication Patterns

for Microservices

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.

Students love the in-person workshop

I taught the material of this course several times times in the form of an in-person workshop before I recorded this new online course. Every time I taught the workshop, I got amazing feedback.

But don't just take my word for it. Here is what other people say:

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:

  • Design and implement the communication between your microservices,
  • Ensure scalability, robustness and data consistency,
  • Build your microservices with confidence.

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 that have been developed for a microservice architecture. This will make your daily work more enjoyable and prepare yourself 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 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 21 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:
    Event-driven services
  • Lecture 10:
    Create domain events to replicate your data

Publishing an event without using a distributed transaction requires new patterns and tools.

  • Lecture 11:
    Outbox pattern
  • 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:
    SAGA pattern
  • 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:
    Event sourcing
  • Lecture 19:
    Event sourcing vs. event-based architectures

If we're talking about event sourcing, we also need to talk about CQRS:

  • Lecture 20:
    CQRS
  • Lecture 21:
    CQRS in a microservice environment

Sign Up Today To Get These Free Bonuses

5-part Video Course: Update your database schema with Flyway


Updating dozens or more horizontally scaled microservices requires much more automation than it did when you just had 2 instances of a monolith.


Database updates now need to be fully automated and version-controlled. This enables you to focus on developing new services instead of updating your database manually. 


Flyway makes that job incredibly simple and is a great fit for microservice applications. In this course, I will show you everything you need to know to start using Flyway in your microservice.


Value $59

Cheat Sheets: Remember the important parts of each pattern


​Remembering all the conceptional and implementation details of the discussed patterns can be tough.

That's why I created 12 cheat sheets highlighting all the details you need to implement the patterns discussed in this course. Put the cheat sheets on your desktop or keep a printout beside your keyboard to have the most critical information at your fingertips whenever you need it.


Value $39

Example Architectures: Combine the patterns to powerful and flexible microservice architectures


Focussing on specific patterns in a lecture video makes each pattern easier to understand. But in a real application, you always need a combination of them to fulfill all business requirements.


In this bonus, I share and explain multiple examples of common pattern combinations. You can use these examples to get a deeper understanding of the discussed patterns and as a blueprint for your next project.


Value $49

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. 

Training Videos

Watch more than 4 hours of Hibernate Performance Training on video.

Example Projects

Get all of the example projects that are used during the course.

Self-Paced

Study at your own pace with lifetime access to all training material.

Exercises

Try what you have learned in practical exercises.

Handout

Get a comprehensive handout with commented slides.

Certificate of Completion

Earn a certificate of completion to prove your expertise.

About the Author

My name is Thorben Janssen, and I'm the author of the Amazon bestselling book Hibernate Tips - More than 70 solutions to common Hibernate problems.

For the last 15 years, I have been using Hibernate and JPA in all kinds of projects. From small ones with very aggressive timelines to huge projects that had to handle thousands of users.

The requirements of these applications were very different and I learned that Hibernate provides good solutions for all of them. You just have to understand the features along with their advantages and disadvantages.

I'm looking forward to showing you how to use Hibernate's advanced features so that you can implement complex persistence requirements with ease.

About the Author

My name is Thorben Janssen, and I'm the author of the Amazon bestselling book Hibernate Tips - More than 70 solutions to common Hibernate problems.

For the last 20 years, I have been working on all kinds of projects. From monolithic ones with millions of lines of code to distributed ones that consisted of a few monoliths to microservice-based applications with hundreds of services.

The requirements of these applications were very different, and I learned that not all patterns are a good fit for every application. In particular, a microservice architecture requires new approaches and tools to ensure data consistency and scalability. That's what our industry has created over the last few years. We got a bunch of new tools and patterns to handle the challenges of a microservice architecture.

I'm looking forward to showing you these new tools and patterns so that you can build your microservices with ease and confidence.

Data and Communication Patterns
for Microservices

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.

Certification Class

$449

  • All Video Lectures
  • A Written Version of all Lectures
  • Example Projects for all Lectures
  • Practical Exercises & Solutions
  • Comprehensive Handout
  • Certificate of Completion
  • Bonus 1: Database Migration Course
    Value $59
  • Bonus 2: Pattern Cheat Sheets
    Value $39
  • Bonus 3: Example Architectures
    Value $49

Certification Class + Consulting

$999

  • All Video Lectures
  • A Written Version of all Lectures
  • Example Projects for all Lectures
  • Practical Exercises & Solutions
  • Comprehensive Handout
  • Certificate of Completion
  • 4 hours of 1-on-1 consulting
    Value $640
  • Bonus 1: Database Migration Course
    Value $59
  • Bonus 2: Pattern Cheat Sheets
    Value $39
  • Bonus 3: Example Architectures
    Value $49

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.

FAQs

Here are answers to some frequently asked questions:

Will we use and create example implementations of the patterns?

What other technologies should I be familiar with?

Which frameworks do you use in the examples and exercises?

Didn't find the answer you're looking for?