Every development team solved its own integration problem.
Point-to-point connections multiplied. Business logic leaked across boundaries. Now every business change triggers a technical scramble, and nobody can fully explain why the system behaves the way it does.
Blaming the technology is pointless. The root cause is that integrations were never treated as a business capability. And an architecture nobody chose, nobody owns, and nobody can safely change is the predictable result.
In this Strategic Integration Design with DDD Workshop, designed and delivered by Philipp Kostyra and Karol Skrzymowski, you will learn how to change that.
You won’t watch. You will model and design.
Learning Objectives
This class is designed to leave you with a reusable methodology. Not a theory to file away, but a playbook you apply to the next integration project and the one after that.
Starting from the day after the workshop, you will be able to:
- Use collaborative modelling to surface where systems must interoperate.
- Identify the architectural decisions already embedded in your system landscape and provide a rationale for changing or keeping each one.
- Apply a trade-off analysis to evaluate event-driven, broker, and API-led architectural styles against your actual business context and communicate your reasoning to engineers, architects, and stakeholders.
The Trainers
Philipp Kostyra is a Development Architect at SAP and a DDD Coach and Trainer with almost a decade spent leading Domain-Driven Design adoption at enterprise scale.
He does not deliver frameworks in isolation. He helps teams reason about boundaries, trade-offs, and long-term consequences, so they can design systems that remain adaptable under pressure.
If your systems are complex, your teams are scaling, and your architecture must support what comes next, this is the work Philipp does.
Karol Skrzymowski is Managing Integration Architect at Capgemini and co-author at BridgingTheGap.eu.com. Having worked across the full spectrum of enterprise integration platforms (Tibco BusinessWorks, webMethods, MuleSoft, Boomi, Azure Integration Services, WSO2), Karol has developed something rare: the ability to distinguish structural integration problems from single-tool problems. Organisations change platforms. The patterns that make an integration fragile or solid remain the same.
Passionate about the “Train the Trainer” (TTT) model.
Target Audience
This course gives your engineers a shared method for making integration choices that are consistent, traceable, and aligned to business direction. The investment pays off every time you avoid the next fire drill.
This workshop is for:
- Engineering Managers and CTOs who want their teams making consistent, traceable integration decisions
- Integration Architects who want to move beyond the plumbing
- Staff and Principal Engineers designing integrations at ecosystem scale
- Solution Architects responsible for system interoperability across domains.
Topics
- Map integration requirements through collaborative modelling. Use EventStorming to surface business processes, events, and bounded contexts, uncovering where systems must interoperate and why.
- Visualise meaning flows. Use Domain Message Flow to trace how events, commands, and queries travel across system boundaries and match them to integration patterns with known trade-offs.
- Navigate implicit architecture. Recognise the signals that an ecosystem has grown without intent: tactical-only decisions, missing rationale, hype-driven choices. Build the case for explicitly addressing it.
- Apply trade-off analysis. Use a structured tool to weigh integration options across coupling, complexity, cost, performance, and evolvability.
- Understand maturity stages. Enterprise Application Integration is not a binary choice. Learn to read your current landscape and plan a strategy that fits where you are.
Choose the right approach for your context. Synthesise everything across all three architectural styles and build an integration strategy grounded in your actual business constraints.
Agenda
Session 1 – Why interoperability fails
- The business case
- Application Integration at System vs Ecosystem level
- DDD strategic context
- Implicit architecture: from efficient point-to-point to spaghetti
- Signals, biases, consequences.
Session 2 – Event-Driven Architecture
- Intra-system communication vs ecosystem-scale events
- Key integration patterns
- Design exercise
- Trade-off analysis in practice.
Session 3 – Broker Architecture
- Mediated interoperability
- Integration Platform concepts
- Key behavioural patterns
- Design exercise
- Trade-off analysis in practice.
Session 4 – API-Led Architecture
- High-complexity ecosystems
- Key integration patterns. Design exercise
- Synthesis: how to choose across all three styles for your specific context
- Integration strategy and next steps.
How it works
Four live online sessions, 3.5 hours each. Every session pairs just enough theory with immediate practice: guided design exercises, trade-off discussions, and group reviews on realistic scenarios.
Each topic follows the same rhythm: problem framing, tools and patterns, hands-on design, group debrief. By the end of each session, you have applied what you learned.
