scala akka microservices fast-data training

Introducing A New Remote/Onsite Training Course To Help Development Teams Learn Reactive Architectures

Bring An Experienced Lightbend Trainer, Best Practices And Practical Techniques On Your Reactive Journey

Clockwise from top left: Wade Waldron (Trainer & Practice Lead), Doug Weatherbee (Training Manager), and Oliver White (Chief Storyteller) have some fun discussing the course :)

With over 20 experts in our Professional Services team, we work on a lot of projects with our clients’ development teams. At the end of the day, all these teams are working to deliver real business value with technologies that can rapidly adapt, change and scale on modern architectures. Deploying infrequently with massive updates and running into scale issues, these clients have realized that their legacy monolithic systems just don’t cut it any more.

Throughout our experiences, we’ve seen that teams who start by changing their way of thinking before coding–making a paradigm shift from old monoliths to Reactive Microservice architecture – are absolutely our most successful customers. Period. It may be an overused quote but “we cannot solve our problems with the same thinking we used when we created them.” Teams that change their thinking upfront get to a modern solution to their business problems faster.

Why This Course?

"This course gave our team more confidence and tools to move forward with the development of our Reactive application knowing we were going to build it correctly the first time.”

L3 Technologies (NYSE: LLL)

Lightbend Reactive Architecture - Professional is a crash course in thinking differently with an experienced guide and guidelines from Lightbend. Lightbend has achieved a record of strong successes with our Reactive Platform technologies. We’ve codified our lessons learned, best practices, reference architectures, design patterns and analysis techniques into the Lightbend Reactive Architecture - Professional training course. You don’t have to figure them out on your own, wasting development time and money.

What Will You Learn?

Lightbend Reactive Architecture - Professional is a jam packed three day course. The course is heavy on practical, highly interactive small group exercises that function as a “design manual roadmap” after the class for the domains your team will be tackling. We’ve built the exercises to model exactly how your team will work post-class.

The course starts by diving into Why Reactive principals are important. It then goes into Domain Driven Design (DDD) theory and practical domain modelling techniques in deep dive group modelling exercises. We move on to evolve the DDD model into Reactive Microservices. The course then dives into the hard problems of distributed programming in Consistency, Availability, Scalability.

A foundation of reactive systems is embracing async communication as discussed and practiced in the exercises of Messaging and Coordination. Finally the course does a deep dive into Command Query Responsibility Segregation and Event Sourcing (CQRS/ES); two essential techniques of reactive systems and architectures.

To get a better idea of how it works, here is some feedback from recent course attendees:

"I am completely new to this area and previously had zero experience or exposure. The course covered topics in a way that allowed me to easily digest each one."
"I have developed monoliths for most of my career; realizing each microservice has its own data store - that shattered my perception."
"This course helped us dig deeper to re-imagine our thought processes and break down pre-existing notions."
"I've come away with a much different way of looking at and resolving problems, which will help me tackle future projects."
"I am new to Reactive with no hands-on experience with microservices. As promised, this course delivered an excellent overview."
"I really appreciated the instructor's involvement during the exercises, which definitely challenged me to think harder."
"I felt it was a good introduction to thinking asynchronously (which I was pretty good at) and thinking about how to separate bounded contexts (which I was not)."