Microservices Architecture with Jorge Ortiz‑Fuentes


6th September 2021   3 days

English   Online Course

£995.00 + VAT

Passionate about distributed applications? Want to develop your knowledge of how to implement microservices using one of the preferred languages for that purpose?

This three-day virtual workshop follows an iterative and constructive path to build complex applications while keeping your code reusable, maintainable, testable and decoupled.

Learn the required theoretical concepts of key architectural topics and use realistic application examples to implement every feature using a step-by-step approach, and understand the principles that inform good architectural decisions, instead of using template implementations of solutions to problems.

Advanced Kubernetes Concepts with Jérôme Petazzoni

This is a hands-on course, where you will write a full-fledged distributed application on your computer with the support and guidance of the instructor. You will also have access to the complete Go code in a Git repository to review parts of the course at your will.

This course will be offered virtually over 3 full-day sessions.

Our virtual courses offer the same expert-led, hands-on experience we've offered since 2013 — accessible from the comfort of your own home (office).

You'll join Jorge and participants from around the globe in a virtual classroom where you'll utilise a variety of collaboration tools (e.g. Zoom, Slack) in this workshop-style course complete with interactive lectures, discussions and hands-on exercises.

Online Courses for Software Professionals at Skills Matter

Learn how to:

  • Write real-world distributed applications using an advanced architecture
  • Target common concerns like communications or resilience
  • Create more reusable and fully testable code
  • Improve collaboration within your team and take advantage of microservice teams
  • Decompose your domain into microservices
  • Create a Proof of Concept (PoC) without worrying about implementation details like the persistence method or how to communicate with other services
  • Iterate from the PoC to get the minimum viable product extending the application with different modules
  • Write independent microservices that communicate among them
  • Create code that is easier to run as a service implementing the 12 factor methodology
  • Implement an API Gateway and understand why is useful
  • Implement service descovery in your infrastructure
  • Choose the best communication mechanisms and implementing in your microservice
  • Apply this knowledge to your current codebase

About the Author

Jorge Ortiz‑Fuentes

Jorge is a freelancer dedicated to mobile development, security, and systems architecture. He started his work as a developer at M.I.T. in 1993 and since has collaborated in numerous software projects. Most of them were internally for HP where he worked for more than 15 years. Since 2008 he has been working in different aspects of mobile development. After playing with PalmOS, he learned Android programming for the first Google App contest and immediately started to play with the first iPhone SDK. He is an instructor in the best iOS and Android Bootcamps in the USA and Europe, and has spoken at some of the world's most renowned conferences about topics relating to mobile app architecture and best practices (and occasionally about Go and Raspberry Pis).

Available dates

Starts at 10:00 AM BST (9:00 AM UTC)
Starts at 9:00 AM BST (9:00 AM UTC)

Can't make it on any of these dates?
Our team is happy to discuss other options with you.
Contact us at and mention ref: MICRO-ARCH-JOF-03.
Private tuition and large-group discounts are also available. Find out more here.

Who should take this course?

This course is intended for Go developers who would like to improve the way they build their distributed applications. Attendees should have at the very least 6 months of experience developing Go code (1 year preferred), know object-oriented programming and what a design pattern is.


Attendees should have at the very least 6 months of experience developing Go applications (1 year preferred) and know object-oriented programming and what a design pattern is.

Course Outline

Day 1
  • Architecture
    • Architecture is for you too: How a good architecture can help us solve the problems that we find when we write mobile apps
    • Using Design Patterns: A basic intro to design patterns and their value in writing good code
    • SOLID Principles: The five SOLID principles, their motivations, and how to apply them
    • (Micro)service architecture vs distributed architecture
  • Clean Architecture
    • Description and Pieces: The pieces that compose clean architecture and their purpose
    • The Dependency Rule: How to deal with dependencies properly in an architecture
    • Hints for Implementation: How to start creating an application that uses clean architecture
  • Decomposition
    • Define Microservice
    • Decomposition Strategies: Subdomains and Capabilities
    • Extract Minimum Viable Product: Plan the application we will write and how to approach the implementation of its features
    • First Design based on microservices
    • Real World strategies for extracting microservicesullet
  • Initial Implementation of the 1st Microservice
    • Define package structure
    • Hardcoded response: Write code for the API that the "user" will interact wit
    • Implement Domain Logic: Create the type that will contain the business logic of the first user story
    • Data (De)Serialization
    • Implement Persistence (Entity Gateway): The needs of persistence and how to implement them
    • Implement Routing (using Gorilla Mux and mentioning Gin and Chi
    • Connect the pieces with a command and make it all work: Write the glue code so all the pieces of the first user story work as expected
Day 2
  • 12 Factor Applications
    • Organize repositories
    • Implement dependencies with Go Modules
    • Add configuration options and use the environment
    • Backing Services: Implement the persistence with PostgreSQL and SQLx
    • Build, release, run: Define Docker images
    • Stateless Processes: Docker containers
    • Port Binding: Docker Compose and networks
    • Concurrency: Consideration
    • Disposability: Graceful shutdown and related tasks
    • Dev/Prod parity: Keeping them similar
    • Logs: The different logging levels microservce, containers, & full application
    • Admin Processes: Implementing database migrations
  • Admin Processes: Implementing database migrations
    • Serving Files
    • API Gateway
Day 3
  • Service Discovery
    • Self Registration
    • Client-side Discovery
    • The Docker and Kubernetes way
  • Sync Communications: Request/Response
    • REST Maturity Levels
    • Defining REST APIs with OpenAPI
    • Compression: Implementing trivial optimizations
    • Versioning REST APIs
    • Using gRPC instead: Use protobuffers and services
    • Versioning gRPC APIs
    • Circuit Breaker: Using Contexts and advantages of Hystrix
  • Async Communications: Publish/Subscribe
    • Messaging: Concepts and standards
    • Message Brokers vs Brokerless
    • Implement messaging
  • Async Communications: Async Request/Response
    • Improve Availability: Using the messaging system for asynchronous request/response
  • Data Consistency
    • Sagas: Problem with transactions and concept for a solution
    • Choreography Sagas
    • Orchestration-based Sagas

Microservices Architecture with Jorge Ortiz‑Fuentes
3 days
Online Course
= start_date
10:00 AM BST
£995.00 + VAT
See more dates