Implementing Microservice Architectures

Microservice Architectures (MSA) are a way of implementing systems as a collection of distinct, independently deployed services. The end result are systems that are highly-available, scalable, resilient, and more maintainable.

This program will teach students how to design and implement microservice architectures using Akka and Kafka. Participants will begin by learning the first-principles of distributed systems design and development before progressing into the most commonly used reactive programming patterns.

Program Overview

Microservices are a hot buzzword in development. This program will remove “marketecture” from microservices by introducing the first principles of distributed systems design. From there, participants are introduced to the core “reactive patterns” that are essential to master before achieving success implementing microservice-based architectures. Participants will learn how to leverage microservices to implement systems that are resilient, scalable, and can evolve to meet the needs of business stakeholders over a long timeframe.

What to expect

This is a 5 day hands-on program with a strong emphasis on participation. Developers will require access to a laptop along with internet connectivity to participate. We will provide all of the required dependencies to follow along with exercises during program delivery.


  • An introduction to Microservice-based Architectures (MSA)
    • The basics of microservices
    • How are microservices different from macroservices and monolithic applications?
    • Why design systems using a microservice-based approach?
  • Core Design Principles
    • Decentralized data
    • Services and modules
    • Designing for failure
    • Modes of concurrency (threads, messages, and events) and when to use each
  • Distributed systems integation patterns
    • Implement an API gateway with the Play framework
    • Core messaging patterns including streams, pub/sub, and point-to-point
    • Integration across bounded contexts with domain events using Akka and Kafka
    • Integration with legacy systems using Akka and the circuit breaker pattern
  • Refactoring heritage/legacy systems for cloud infrastructure (optional)
    • How to leverage the actor model to enable legacy Java code for the cloud
    • How to protect other legacy systems from failure using circuit breakers
    • Real-world advice from your instructors on how to position yourself for success with Akka on cloud-enablement projects using Akka
  • Data
    • CQRS (Command Query Responsibility Segregation)
    • Immutable data
    • Event-sourcing and durability
    • Streaming integration within a bounded context
    • Message formats, managing changes to contracts with schemas, and schema registries
  • Infrastructure Essentials
    • Continuous integration
    • Continuous delivery
    • Monitoring
    • Reducing network saturation bottlenecks


We strongly recommend that participants first complete Reactive Systems Analysis and Design for Business, which covers the importance of “thinking in events” from a business perspective. Once fundemantal modeling skills are learned, technical teams are ready to dive into the specifics of how to implement reactive systems using microservices.

Participants are also required to have experience with Play and Akka, which can be obtained through our introductory developer programs:

Contact Us To Discuss Training Contact Us