KanDDDinsky 2025: Our First Time at Europe's Community-Driven DDD Conference

Last week, my colleague Rendani and I found ourselves in Berlin's nhow hotel, surrounded by about 250-300 people who share our passion for Domain-Driven Design (DDD), Event Sourcing, and thoughtful software architecture. KanDDDinsky 2025 marked our first time attending this conference – not just as participants, but as sponsors and exhibitors for EventSourcingDB.

If I had to describe the atmosphere in one word, it would be "dense." Not oppressive, but full. The kind of fullness that comes from many simultaneous conversations, ideas bouncing between people, and the productive buzz of a community that's genuinely excited to be together. The pink-themed venue (which, delightfully, happens to be our company color) was well-equipped, well-catered, and perhaps a touch too air-conditioned – but that's a small price to pay for comfort when hosting hundreds of enthusiastic technologists.

A Different Kind of Conference Format¶

One thing that immediately stood out to us was KanDDDinsky's approach to scheduling. Rather than the typical conference format of uniform session lengths, the organizers created a puzzle-like agenda mixing 50-minute talks with 120-minute hands-on workshops. Sessions ran in parallel across four tracks: Music Hall 2, Music Hall 3, Music Hall 4, and Soul.

This format creates interesting choices for attendees. While theoretically you could switch between sessions, the reality is more nuanced. Leaving a two-hour workshop halfway through to catch a talk doesn't make much practical sense, though we did notice some people quietly slipping out of talks at the midpoint to catch another session. It's an elegant solution that accommodates both deep dives and rapid knowledge sharing – something we haven't encountered quite this way at other conferences.

The four-day structure was equally thoughtful: workshops on Tuesday (October 21st), the main conference on Wednesday and Thursday (October 22nd-23rd), and an Open Space on Friday (October 24th). This progression from focused learning to broad exploration to community-driven conversation shows careful consideration of how people actually want to engage with conferences.

The Content Landscape¶

Looking at the two-day agenda, the breadth of topics was striking. Wednesday opened with an interactive keynote exploring modeling in both software and human systems, while Thursday featured talks ranging from Ian Cooper's "The Emissary" to Eric Evans himself speaking on "AI and Tackling Complexity." The classics were there – CQRS, Event Sourcing, DDD patterns – but they sat alongside sessions on Wardley mapping, collaborative modeling, hexagonal architecture, and organizational design.

Several themes emerged across both days. AI's intersection with DDD was impossible to ignore: Rinat Abdullin's "When DDD Met AI: Practical Stories from Enterprise Trenches," Eric Evans on tackling complexity with AI, and Hila Fox discussing socio-technical systems in the AI era all pointed to a community actively wrestling with how these worlds collide. The hands-on workshop "Epic Systems Design: Surviving Complexity" by Jacqui and Steven Read ran on Thursday, as did a reflective session asking "Over 20 Years of DDD – What We Know, What We Do, What Needs to Change" – a meta-conversation about the practice itself.

What particularly interested us was seeing how naturally AI made its way into the discourse. Sessions like Marco Heimeshoff's "Hybrid Intelligence" and the various AI-focused talks weren't treated as novelties but as natural extensions of the community's core concerns. This aligns perfectly with something we've been exploring at eventsourcing.ai – how AI and event-driven architectures can complement each other in meaningful ways. The benefits of event-driven architectures for AI applications – auditability, time-travel debugging, deterministic replays – are becoming increasingly clear to practitioners.

Thursday's closing keynote by Alberto Brandolini on "DDD Lessons from ProductLand" bookended the main conference days, bringing one of the community's luminaries to reflect on how DDD insights apply beyond pure software development.

The conference was entirely in English, reflecting its truly international character. Attendees came primarily from Europe – Germany, Austria, Italy, and beyond – creating a diverse but cohesive community. Inclusion clearly matters to the organizers, evident in both the speaker lineup and the way the event was structured.

Conversations at the Booth¶

Spending most of our time at the booth gave us a unique perspective. The most common question we heard was straightforward: "What is EventSourcingDB, and what is OpenCQRS?"

Our answer usually started with explaining that EventSourcingDB is a database purpose-built for Event Sourcing – one that aims to be both powerful and accessible. It's a statically-linked binary you can download and start with a single command, or run as a Docker image if that better fits your infrastructure. A few CLI flags, and you're running. No complex setup, no operational overhead. OpenCQRS, on the other hand, is a CQRS-based framework for application development on the JVM, providing the building blocks teams need to implement command-query separation patterns effectively.

As Leonardo da Vinci put it centuries ago:

"Simplicity is the ultimate sophistication."

Making something simultaneously simple and sophisticated is deceptively difficult. Many databases sacrifice one for the other – either they're easy to start but hit performance walls, or they're powerful but require deep expertise to operate. We're working to prove you can have both.

The response was overwhelmingly positive. People appreciated what they called "fresh wind in the market." The lightweight approach resonated particularly well. In an industry that often defaults to complexity, there's real hunger for tools that respect developers' time and cognitive load without compromising on capabilities.

What struck us most was the openness. People weren't just curious – they were genuinely interested in exploring new approaches. The DDD community, at least the slice of it we met at KanDDDinsky, isn't dogmatic. They're pragmatic experimenters looking for better ways to build software, and they're willing to consider new tools and techniques if they make sense.

The Broader Takeaway¶

Perhaps our biggest insight from the days wasn't about any particular technology or pattern – it was about the community itself. There's a perception, sometimes, that DDD, CQRS, and Event Sourcing are niche interests, practiced by a small group of enthusiasts in isolated pockets.

KanDDDinsky challenged that perception. Yes, these approaches aren't what everyone does. They're not the default that ships with every framework or gets taught in every bootcamp. But they're not exotic either. Looking around that pink-hued conference space, seeing hundreds of practitioners from dozens of companies and countries, the reality became clear: this is a substantial, growing community with real-world experience building production systems.

The conversations we had weren't theoretical. People are solving actual problems with these patterns. They were wrestling with real trade-offs, sharing war stories, and learning from each other's successes and failures. This is a mature practice area, not an experimental fringe.

For us, that validation matters. We're building EventSourcingDB because we believe Event Sourcing and CQRS deserve first-class tooling support. Seeing this community's size and engagement confirms there's real demand for tools that make these patterns more accessible.

Looking Forward¶

The two conference days set a strong tone, with Friday's Open Space still ahead to continue the conversations in a more emergent format. The mix of talks and workshops created natural rhythms – intense learning sessions followed by networking and digestion. The venue worked well, the organization was smooth, and the community was welcoming.

We're still processing everything we learned and everyone we met. That's the mark of a good conference – when you leave with more questions than answers, and more connections than you can immediately follow up on.

KanDDDinsky gave us a glimpse of that future, and it looks promising. Dense, full, and buzzing with ideas – just the way we like it. We're already looking forward to continuing these conversations and seeing how this community shapes the next generation of event-driven systems.