Microservices Architecture training course

A "World Class" course - Learn The Principles Of Microservices Architecture - Build Modern, Scalable, Highly Available and Easily Maintainable Applications

JBI training course London UK

"It felt like a thorough dive into a microservices driven approach and the surrounding context. In particular I found the more technical discussion of architecture approaches (DDD, SOA, Event-driven stuff) very useful indeed"  

GH, Software Engineer, Microservices, July 2021

Public Courses

14/09/26 - 2 days
£1995 +VAT
26/10/26 - 2 days
£1995 +VAT
07/12/26 - 2 days
£1995 +VAT

Customised Courses

* Train a team
* Tailor content
* Flex dates
From £1200 / day
EDF logo Capita logo Sky logo NHS logo RBS logo BBC logo CISCO logo
JBI training course London UK

  • Understand microservices and the relationship with SOA and DevOps
  • Move from business requirements to service design
  • Learn the principles of microservices architecture
  • Learn techniques for designing and migrating to a microservice architecture
  • Understand communicating infrastructure technologies
  • Appreciate how to use tools for enabling microservices
  • Incorporate security, testing and quality into a microservices architecture
  • Monitor microsystems and size appropriately for maximum scalability
  • Build modern, scalable, highly available and easily maintainable applications

What are Microservices?

  • Small and focused                                                  
  • Loosely coupled                                                     
  • Language-neutral                                                   
  • Bounded context    
  • Domain-driven design                                               
  • Comparing microservices and monolithic architectures                  

Benefits from Microservices

  • Enterprise solutions context                                
  • Challenges with monolithic architecture      
  • Developer perspective                                              
  • Tester perspective                                                  
  • Business owner perspective                                 
  • Service management perspective   
  • Exercise: Try out a SOAP and REST service using Postman          

Analysing and Designing microservices

  • What is a microservice application?
  • Scaling through Decomposition
  • Key Principles
  • Who uses microservices?
  • Domain-driven Design
  • Service Analysis, Design and implementation
  • Exercise: Analyse course case study and use Domain driven design

API Management                        

  • API Economy in Numbers
  • API-Led Architecture
  • Hypermedia
  • API Gateway
  • API Micro Gateways
  • Sidecar pattern
  • Exercise: Write OpenAPI or Swagger contract

Microservices today                  

  • Microservices at Robinhood
  • The contents of an Event
  • Exposing Services to the World
  • Exercise: Build a service using java, maven and Spring boot

Architecture of a Microservices Application

  • Role of the Architect
  • A microservice platform
  • Services layer          
  • Communication
  • Locating Services
  • The application boundary
  • Client layer
  • Exercise: Configure a services registry such as Eureka

Architectural Modularity

  • Technical Drivers
  • Business Drivers
  • How Much Modularity is enough?
  • Sacrificial Architecture
  • Exercise: Build a Micro Frontend with Node.js and Angular spa

Service Design

  • Micro Hexagonal Service Design Pattern 
  • Service Taxonomy
  • Identifying Taxonomy

Service Granularity

  • Purpose and Service Scope
  • Transactions
  • Data Dependencies
  • Workflow and Choreography
  • Code Structure and Reuse
  • Exercise: Configure an API gateway

Share Nothing Architecture

  • Bounded Context
  • Shared Libraries
  • Sharing a Database and Schema

Inter-service communication Using gRPC

  • Using gRPC Between Services
  • How gRPC Works
  • Load Balancing gRPC Servers 
  • Exercise: Configure an API gateway (example Nginx) to load balance request

Orchestration and Choreography

  • Defining Orchestration
  • Defining Choreography
  • Service Orchestration
  • Issues with Gateway Orchestration
  • Using Microservice Orchestrators
  • Orchestration and Loose Coupling
  • Exercise: Walk through some Saga code

Service Aggregation

  • Aggregation vs. Orchestration
  • Issues with Orchestration
  • Using Service Aggregation
  • Aggregation Use Cases

Deploying Microservices                                

  • Why is Deployment important?
  • A microservice production environment
  • Serverless Computing
  • Building Service Artefacts
  • Securing the Services
  • Service to Host models
  • Containerizing a Service
  • Deploying to a Cluster
  • Deploying services without downtime
  • Exercise: Deploy a service to a Docker container

Transactions and Queries with Microservices

  • Consistent transactions
  • Event-based communication
  • Sagas
  • CQRS
  • Event Sourcing
  • CAP Theorem
  • Exercise: Configure MongoDB and H2 for command and query side to test CQRS pattern

Microservices and Distributed Data

  • Change Control Issues
  • Connection Issues
  • Bounded Context and Data
  • Exercise: Using polyglot persistence

 

Distributed Data Issues

  • Data Sharing and Choreography
  • Data Sharing and Data Replication
  • Sharing data between Services
  • Using Replicated Caching
  • Limitations and Restrictions

Designing Reliable Services

  • Defining Reliable Service
  • What could go wrong
  • Designing reliable communication
  • Maximizing service reliability
  • Exercise: Using Kubernetes
  • Service Mesh
  • Exercise: Using Istio and Envoy to build a simple service Mesh

Building a Delivery Pipeline for Microservices

  • Making deploys boring
  • Building a pipeline with Jenkins
  • Building reusable pipeline steps
  • Exercise: Configure Jenkins

DevOps and Microservices 

  • Why you should use DevOps                                             
  • Defining DevOps                                                   
  • DevOps, a prerequisite to successfully adopting microservices?       
  • Organizing teams to support microservices      

Using an Event Broker

  • Building Topologies
  • Event-driven Approach
  • Processing Events with Stateful Functions
  • Making Events the source of truth
  • Exercise: Using Kafka

Microservices governance     

  • Centralized versus decentralized governance
  • Enterprise transformation for microservices
  • DevOps capabilities: Testing strategies for microservices 
  • Considerable testing methods     
  • Building a sufficient testing strategy        

Hybrid Architectures

  • Issues with Microservices for Business Applications
  • Service-Based Topology
  • Advantages of Service-Based Architecture
  • Topology Configurations
  • Managing Database Changes
  • Microservices: a few epic fails

Testing Microservices

  • Testing Strategies
  • Writing Unit Tests
  • Writing Integration Tests
  • Developing Component Tests
  • Writing End-to-End Tests
  • Exercise: A quick look at Cucumber and Gherkin

 

JBI training course London UK

This course is suitable for Enterprise Architects who need to design flexible large-scale systems and oversee agile development of services that meet business needs. Developers and Analysts may also find this course useful as a means of gaining a broader background in Microservices Architecture.

 


5 star

4.8 out of 5 average

"It felt like a thorough dive into a microservices driven approach and the surrounding context. In particular I found the more technical discussion of architecture approaches (DDD, SOA, Event-driven stuff) very useful indeed"  

GH, Software Engineer, Microservices, July 2021



“JBI  did a great job of customizing their syllabus to suit our business  needs and also bringing our team up to speed on the current best practices. Our teams varied widely in terms of experience and  the Instructor handled this particularly well - very impressive”

Brian F, Team Lead, RBS, Data Analysis Course, 20 April 2022

 

 

JBI training course London UK

Certification


Every delegate will be entitled to a certificate of achievement on completion of the course.

If you are missing your certificate - please use the link below to apply - you can also use this link to sign up for the JBI Training newsletter to receive technology tips directly from our instructors - Analytics, AI, ML, DevOps, Web, Backend and Security.
 



In this Microservices training course you will learn a modern approach for building scalable, highly available and easily maintainable applications.

We will describe the microservices architecture and show how it enables the agile development and deployment of applications. You will learn about Domain-Driven Design and tools that enable microservices.

You will gain an understanding of microservices and the relationship with SOA and DevOps, learn techniques for designing and migrating to a microservices architecture, understand communicating infrastructure technologies, appreciate how to use tools for enabling microservices, and incorporate security, testing and quality.  You will also learn how to monitor microsystems and size appropriately for maximum scalability. 

JBI Training offers eleven courses in this group. Architecture and design courses include Microservices Architecture (two days), Software Architecture (two days), SOA for Architects and Managers (two days), SOA for Developers (three days), Advanced SOA (two days), SOA and BPM (three days), and SOA with BizTalk Server (five days). Development practice courses include Behaviour Driven Development (one day). Digital Sustainability courses include Digital Sustainability Introduction (one day), Digital Sustainability for Developers (one day), and Digital Sustainability for Business Analysts (one day). All are available in London, online, or as customised onsite programmes.
Service-Oriented Architecture (SOA) and Microservices are both approaches to building systems from independent, reusable services, but they differ in scope and granularity. SOA is typically an enterprise-wide approach using standardised protocols and an Enterprise Service Bus (ESB) to integrate large, coarser-grained services across an organisation's systems. Microservices takes a finer-grained approach — decomposing applications into very small, independently deployable services that communicate via lightweight APIs, typically within a single application domain. Microservices are often considered an evolution of SOA principles applied at a smaller scale and with cloud-native tooling. Many organisations with legacy SOA infrastructure are gradually adopting microservices for new workloads. JBI's courses cover both approaches and can help teams understand the trade-offs between them.
The two-day Software Architecture course covers the principles and patterns that software architects and senior developers use to design robust, maintainable, and scalable systems. Topics include architectural styles and patterns — including layered, event-driven, hexagonal, and microservices architectures — quality attributes such as scalability, resilience, and security, architectural decision-making and trade-off analysis, documenting architecture using standard notations, and how modern cloud-native and AI-integrated systems are influencing architectural approaches. It is suited to senior developers, technical leads, and architects who are responsible for high-level system design decisions.
JBI offers four SOA courses for different roles and depths of knowledge. SOA for Architects and Managers is a two-day course for non-developers who need to understand SOA principles, governance, and strategic implications. SOA for Developers is a three-day hands-on course for engineers implementing service-oriented solutions. Advanced SOA (SOA 2.0) is a two-day course for experienced SOA practitioners covering advanced patterns, governance models, and the relationship between SOA and cloud-native approaches. SOA and BPM is a three-day course combining service-oriented architecture with Business Process Management — covering how BPM orchestration layers sit above SOA service layers in enterprise architectures. SOA with BizTalk Server is a five-day course for teams implementing SOA using Microsoft BizTalk as the integration backbone.
The two-day Microservices Architecture course covers the principles and patterns for designing and implementing microservices-based systems. Topics include the characteristics of a well-designed microservice, domain-driven design as a basis for service decomposition, inter-service communication patterns including synchronous REST and asynchronous messaging, managing data consistency across services, service discovery and load balancing, resilience patterns such as circuit breakers and retries, containerisation with Docker, orchestration with Kubernetes, and the operational challenges of running microservices in production. It is suited to software architects, senior developers, and technical leads who are designing or evolving distributed systems.
Behaviour Driven Development (BDD) is a software development practice that bridges the communication gap between technical and non-technical team members by expressing system behaviour in plain-language scenarios using the Given-When-Then format. It sits naturally alongside architecture and design courses because good architectural decisions are grounded in a clear understanding of how a system should behave from a business perspective. JBI's one-day BDD course covers writing behaviour scenarios with Gherkin, working with tools such as Cucumber, and integrating BDD into Agile and architectural workflows. It is relevant for developers, testers, business analysts, and architects who want to establish a shared, executable specification between technical and business stakeholders.
Yes. All courses in this group can be delivered as customised onsite or online programmes for corporate architecture, engineering, and development teams. Content can be tailored to the team's existing architecture, technology stack, cloud provider, and specific design challenges — for example, a team migrating from a monolithic application to microservices can receive training focused on decomposition strategy, data migration, and incremental delivery, while an enterprise architecture team can receive SOA training aligned to their existing integration infrastructure and governance framework. JBI has delivered architecture and software design training for teams at organisations including the BBC, NHS, RBS, Sky, EDF, and Cisco.

CONTACT
+44 (0)20 8446 7555

[email protected]

 

Copyright © 2026 JBI Training. All Rights Reserved.
JB International Training Ltd  -  Company Registration Number: 08458005
Registered Address: Wohl Enterprise Hub, 2B Redbourne Avenue, London, N3 2BS

Modern Slavery Statement & Corporate Policies | Terms & Conditions | Contact Us

POPULAR

AI training courses                                                                        CoPilot training course

Threat modelling training course   Python for data analysts training course

Power BI training course                                   Machine Learning training course

Spring Boot Microservices training course              Terraform training course

Data Storytelling training course                                               C++ training course

Power Automate training course                               Clean Code training course