Strategic Integration Design with DDD

Most integration landscapes grow messy, siloed, and become hard to change. This course shows you how to design interoperability with purpose. Apply Domain-Driven Design to integrate architecture so your systems work together, scale with your organization, and stay aligned to your business needs.

Overview
Organizations often reinvent the wheel when connecting systems. Custom point-to-point solutions emerge, silos deepen, and technical decisions drift away from business intent. This results in unwanted complexity that slows delivery and limits agility.
Strategic Integration Design with DDD equips your team to turn integration into a strategic capability. By combining collaborative modeling with proven integration patterns, you will learn how to design flows that serve business goals, create reusable assets instead of one-off fixes, and evaluate when larger transformation steps are needed. Along the way, you will see how interoperability follows organizational structure (Conway’s Law in action) and how reducing different kinds of coupling leads to systems that can evolve with the business.
Participants value this course because it gives names and theories for practices they already use informally, demystifies industry jargon and introduces practical tools for comparing trade-offs.

What You’ll Learn
Elicit integration requirements with EventStorming: Quickly map business processes, events, and bounded contexts to uncover where systems must interoperate.
Depict flows with Domain Message Flow: Visualize how events, commands, and queries travel across systems, and match them to well established integration patterns.
Apply trade-off analysis: Use a structured tool to weigh integration options and choose with confidence.
Recognize maturity stages: Understand the complexities of Enterprise Application Integration (EAI), and that they are not binary choices.
Reduce coupling: Identify different types of coupling, and learn how to balance them.
Demystify architecture styles: Place different approaches in context, clarifying what they solve and where their limits are.
Plan integrations purposefully: Design reusable solutions directly aligned with business needs, rather than ad-hoc fixes.

Why Attend?
Strategic clarity: Understand which integration approaches fit your context and how to explain trade-offs to stakeholders.
Shared language: Give teams a vocabulary to describe integration patterns and styles, reducing confusion and reliance on constantly misused buzzwords.
Direct applicability: Learn techniques & methods, which you can apply directly to your current business problems and system.
Organizational awareness: See how interoperability depends on the way teams are structured, and how to align system boundaries with business domains.
Future-proofing: Design integrations that remain flexible and reusable as your organization and technology landscape evolve.

Migrating away from IPaaS Technologies

The rising operational and licensing costs of iPaaS platforms like Mulesoft are pushing many enterprises to consider migration to custom, self-developed and self-hosted integration solutions. This transition, dubbed "migrating away from iPaaS technologies," is often framed as a simple cost-cutting measure. But does moving away from a managed platform truly save money, or does it shift complexity and hidden expenses elsewhere? The secret is that the only correct answer is "it depends."

During this session we will explore the various reasons companies would want to migrate from an IPaaS, and look at a structured Total Cost of Ownership (TCO) specifically focused on evaluating iPaaS vs. custom-built integration strategies. We will explore the hidden costs in both scenarios, including infrastructure maintenance, developer skill retention, security hardening, and operational overhead, which are often overlooked in initial calculations.

The board overview of TCO will enable Architects, Product Owners, or Consultants to have a fact based conversation and make an informed decision that protects the existing IT ecosystem and the business. The key is ensuring you understand the true financial and technical trade-offs before you start the migration.

Target audience: Architects, Product Owners, Consultants, IT Decision Makers,
Preffered duration: 40-45 minutes,

Integration Design with DDD

In today's rapidly evolving technological landscape, businesses rely heavily on interconnected systems to operate efficiently. However, integrating these distributed systems seamlessly presents significant challenges. Enterprise Application Integration (EAI) has become a critical aspect of modern software architecture, and achieving true interoperability requires more than just technical solutions. This workshop explores how to leverage the tools provided by Domain-Driven Design (DDD) to not only address the technical hurdles of EAI but also to align integration efforts with the core business domains. We will move beyond simply connecting disparate systems and delve into understanding the underlying business logic and data flows that must be integrated. This interactive workshop aims to provide you with practical, actionable knowledge and hands-on experience. You'll participate in scenario-based exercises, collaborative discussions, and trade-off analysis, ensuring you leave with new skills and tools to explore that will allow you to tackle real-world integration challenges.

Key Activities:

• Trade-Off Analysis: Perform comparative assessments of architectural options, weighing their pros and cons relative to the scenario's requirements.
• Quality Attributes Focus: Each scenario will highlight one or two critical architectural characteristics (e.g., "Time to Market," extensibility, composability) of EAI, which will be introduced and discussed.
• Decision Justification: Articulate the reasoning behind architectural choices, fostering a deeper understanding of how to align technical decisions with business needs.

Key Learnings: By the end of this workshop, you will have gained:

• Interoperability as a first-class citizen in architectural design. Understand the importance of designing systems with interoperability in mind from the start.
• Practical experience in using DDD to determine appropriate coupling degrees between systems. Learn how to strategically manage dependencies and connections between systems using DDD principles.
• Insights into selecting the right Ecosystem Architectural Style to facilitate seamless integration. Gain the ability to choose the most suitable architectural style from a range of options (Point-to-point, Event-Driven Architecture, Broker Topology, API-Led Architecture).

Format: Workshop;
Size: 16 - 20 participants;
Target audience: developers, solution architects, integration architects
Duration: 2h - 3h;
Room requirements: 4-5 whiteboards or other surfaces for writing (pane of glass, flipchart paper on walls); TV screen or multimedia board;
Supplies: green, blue, orange post-its, cloud shaped post-its; makers (3 or 4 colours) x 5
Workshop requires handouts ot be printed on A4 and A3/plotter formats.

The Context lost in integration

Modern systems are distributed, but our design language still treats integration as a technical desadftail. We name bounded contexts, define ubiquitous language, and protect models with anti-corruption layers. Then we wire everything together with brokers, iPaaS flows, and glue code, and we act surprised when semantics drift, coupling explodes, and integration becomes the bottleneck.

This talk introduces the Interchange Context as a first-class bounded context whose domain is interoperability. An Interchange Context sits between bounded contexts and owns the meaning of what they exchange: contracts, translations, versioning policies, and cross-context coordination rules. It is not an ACL that lives inside one context. It is a standalone context that can protect both sides.

We will classify Interchange Contexts into practical types: Neutral Relay, Conforming, Transforming, Supervising, and the cautiously used Canonical Interchange. You will learn how these types show up differently across architectures. In Event-Driven Architecture, bitsemantic work belongs at the edges, and the backbone should remain a relay. In Broker Architecture, the integration platform becomes the natural host for Interchange Contexts.In API-led Architecture, contracts can become stable published languages that enable transforming interchange without forcing every participating system to conform.

We will show how to design an explicit Interchange Context with clear semantic ownership.

Moving Beyond the Bounded Context: A Short Guide to Designing for Interoperability with DDD

We've mastered designing our bounded contexts and internal systems, but what happens when our designs meet the outside world? All too often, interoperability is treated as a last-minute detail - an API added at the end of a project. This "design-it-later" approach can lead to significant refactoring and unnecessary complexity. To build systems that thrive in a connected ecosystem, we must make interoperability a first-class citizen in our design process.

This talk explores how to apply Domain-Driven Design principles beyond your system's boundaries. We'll explore how to challenge the "curse of knowledge" by stepping into the shoes of an external consumer. By "productizing" our APIs and events, we can shift our focus from what our system does to what value it provides to others. We’ll also take a closer look at how ecosystem architectural styles - such as broker or API-Led Architecture - may influence our design decisions. We'll identify the repeatable factors that make an API or event truly great, from data model to documentation, and discuss how to design for a constantly evolving ecosystem.

Join me to learn how to design for interoperability from the start, ensuring your system communicates well and provides maximum value to all who consume it.

Audience Takeaways
• Learn how to "productize" APIs and events, focusing on the value they provide to external consumers.
• Understand why designing for interoperability from the start is critical.
• Gain strategies for overcoming the "curse of knowledge" to create more intuitive designs.
• Explore how different architectural styles influence your design decisions for interoperable systems.

• Preferred Duration: 40-60 minutes
• Technical Requirements: Standard projector and microphone. No special software or hardware required.
• Target Audience: Intermediate-level developers, architects, and managers with a foundational knowledge of Domain-Driven Design (DDD).