Designing Distributed Systems: Making Hard Architectural Decisions

Name: Designing Distributed Systems: Making Hard Architectural Decisions
Start: 2025-10-21T09:00:00+03:00
End: 2025-10-22T17:00:00+03:00
Location: Hotel Ramada Iasi City Center

Schedule

Tue, 21 Oct, 2025 at 09:00 am to Wed, 22 Oct, 2025 at 05:00 pm

UTC+03:00

Location

Hotel Ramada Iasi City Center | Iasi, IS

This updated 2-day class (based on the prior "Architecture: The Hard Parts" class) takes a deep dive into the hard decisions architects face when creating or migrating to distributed system - hard decisions involving service granularity, data topologies, communication protocols, workflow management, and distributed transactions (to name a few).
This course starts out with a deep dive exploring the differences between architectural modularity and service granularity, explaining why distributed architecture are so important in today’s world and how to get service granularity right. It then dives into defining the structure of distributed architectures, introducing the concept of an architectural quantum.
Taking a deep dive into the realm of data, we’ll explore various data topologies, and the corresponding tradeoffs associated with each. Here, you’ll learn how to align a distributed architecture with the most appropriate data topology, how to create bounded contexts, how to access data a service no longer owns, and finally various patterns for contracts and message payload.
Knowing that everything is not always microservices, this course then dives into event-driven architecture, exploring various event patterns and techniques for solving difficult problems when using asynchronous communication and event processing.
In the last part of the course, you’ll learn about the three primary decisions an architect faces when designing distributed systems—communication (async or sync), workflow (orchestration or choreography), and transactions (atomic or eventual consistency). The class concludes by bringing all three of these critical decisions together in the form of transactional sagas, simplifying the hard decisions an architect faces when designing distributed systems.
Designing distributed architectures is hard—very hard. By attending this 2-day class you’ll gain the insights and techniques to make it just a little softer.
Course contents
Unit 1: Architectural Modularity
Defining modularity and why it’s important
Business and technical drivers
Hands-on exercises: Modularity drivers

Unit 2: Service Granularity
Grains of sand anti-pattern
Granularity disintegration drivers
Granularity integration drivers
Analyzing tradeoffs
Hands-on exercises: Determining service granularity
Unit 3: The Structure of Distributed Systems
Concepts: Architectural quantum and its importance
Architecture quantum examples
Hands-on exercises: Identifying architectural quanta
Unit 4: Data Topologies for Distributed Systems
Monolithic data topology
Domain data topology
Database-per-service topology
Data topology tradeoffs
Aligning data topologies with distributed architectures
Creating data domains
Resolving data dependencies
Hands-on exercises: Choosing the right data topology
Unit 5: Data Ownership and Access
Creating bounded contexts: Service granularity revisited
Managing common data ownership
Managing joint data ownership
Remote data access patterns
Data topology coupling revisited
Hands-on exercises: Accessing remote data

Unit 6: Contract and Payload Patterns
Data-based payloads
Key-based payloads
Data payload tradeoff analysis
Anemic events

Unit 7: Event-Driven Architecture Patterns
Event-driven architecture review
Derived event granularity
Swarm of gnats event anti-pattern
Hands-on exercises: Identifying derived events
Extensible event pattern
Event forwarding pattern

Unit 8: Communication Protocols
Synchronous communication
Asynchronous communication
Dynamic quantum entanglement
Hands-on exercises: Asynchronous communication
Unit 9: Managing Workflows
Orchestration workflows and tradeoffs
Choreography workflows and tradeoffs
Front controller hybrid pattern
Combining workflow topologies
Managing workflow state
Unit 10: Distributed Transactions
ACID (database) transactions
BASE (distributed) transactions
Compensating updates
Managing transactions through state machines
Hands-on exercises: Creating a workflow saga
Unit 11: Transactional Sagas
Transactional sagas explained
Epic Saga
Fantasy Fiction Saga
Fairy Tale Saga
Parallel Saga
Phone Tag Saga
Horror Story Saga
Time Travel Saga
Anthology Saga
Transactional sagas as a tool
Target audience and prerequisites
This course is for software developers that want to become software architects and for software architects that want to focus on problems within distributed architectures such as microservices and event-driven systems.
Mark Richards is an experienced, hands-on software architect involved in the architecture, design, and implementation of microservices architectures and other distributed systems in a variety of technologies. He has been in the software industry since 1983 and has significant experience and expertise in application, integration, and enterprise architecture. Mark is the founder of DeveloperToArchitect.com, a free website devoted to helping developers in the journey to becoming a software architect. In addition to hands-on consulting, Mark has authored numerous technical books and videos, including his three latest books Fundamentals of Software Architecture, Software Architecture: The Hard Parts, and Head-First Software Architecture. Mark has spoken at hundreds of conferences and user groups around the world on a variety of enterprise-related technical topics.
https://codecamp.ro/masterclasses/fundamentals-of-software-architecture-iasi-2025/