The role of software developers is changing. Following the emergence of AI-based development tools, developers are gradually moving to a higher level of abstraction. Writing syntax is still important, but it is no longer the main professional differentiator. More and more, the value of the developer is expressed through design decisions, architectural understanding, modeling skills, and the ability to guide machines toward correct, maintainable, and scalable solutions.
The Motivations for This Series of Meetups
This change provides the main motivation for this series of 10 free meetups about microservices architecture and design patterns. The focus will not be on a specific programming language, framework, or syntax. Instead, we will focus on the mental models behind microservices: how to split systems into services, how services communicate, how data consistency is maintained, how queries are implemented, and how external clients interact with distributed systems.
The Full Meetup Series Schedule
Communication Patterns Between Microservices
In this meetup, which will take place on September 1, we will explore how microservices communicate with each other. We will compare synchronous communication using Remote Procedure Invocation with asynchronous communication using messaging.
Service Discovery Patterns in Microservices
In this meetup, which will take place on October 10, we will discuss how services discover one another when instances are created, removed, scaled, or moved dynamically. We will introduce client-side discovery, server-side discovery, service registries, self-registration, and third-party registration, and explain why service discovery becomes essential in dynamic microservices environments.
Broker Based Communication in Microservices
In this meetup, which will take place on December 1, we will focus on broker-based messaging in microservices. We will discuss how asynchronous messaging helps decouple services, supports event-driven workflows, improves resilience through buffering, and enables publish/subscribe communication.
The Saga Pattern for Distributed Transactions
In this meetup, on January 5, 2027, we will explore the Saga pattern for managing business transactions that span multiple services. We will discuss local transactions, compensating actions, choreography, and orchestration
Event Sourcing in Microservices Architecture
In this meetup, on February 2, 2027, we will explore the Event Sourcing pattern. Instead of storing only the current state of an entity, event sourcing persists aggregates as a sequence of events. We will discuss rebuilding the state by replaying events.
The API Composition Design Pattern
In this meetup, on March 2, 2027, we will discuss the API Composition pattern for implementing queries across multiple services. We will see how an API Composer invokes the services that own the data, joins the results in memory, and returns a unified response. We will also review limitations around latency, availability, and complexity.
The CQRS Pattern in Microservices Architecture
In this meetup, on April 6, 2027, we will explore the Command Query Responsibility Segregation pattern. We will discuss why commands and queries can use different models, and how this pattern helps when the data required by a query is owned by multiple services.
The API Gateway Design Pattern
In this meetup, on May 4, 2027, we will explore the API Gateway pattern. We will discuss how an API Gateway provides clients with a unified interface to services, hides internal service structure, supports client-specific APIs, and handles concerns such as routing, security, protocol translation, and request aggregation.
Who Should Attend These Meetups
These meetups should fit every software developer. It does not matter whether you use Java, JavaScript, TypeScript, Python, C#, Kotlin, Go, PHP, Scala, or any other language. The important question is not which syntax we use. The important question is whether we understand the architecture we are asking humans and machines to build.
I hope that this series of meetups will help software developers adapt to the new professional reality created by AI. As machines become better at generating code, developers must become better at understanding architecture, identifying tradeoffs, asking the right questions, and making design decisions that lead to systems that are maintainable, reliable, and scalable. The microservices architecture is not just a collection of technologies. It is a way of thinking about boundaries, ownership, communication, data, deployment, and change. These mental models are becoming increasingly important for every developer, regardless of programming language or platform. Companies that want their software developers to polish their understanding of the microservices architecture and its design patterns are welcome to hire my training services for focused, practical, and professional learning sessions tailored to their teams.
