Paul Rayner's Speaker Profile @ Sessionize

Rework is Just Discovery You Paid For Twice

Rework feels like a technical problem. It's usually a discovery problem - insights that arrived too late to be cheap.

EventStorming is collaborative discovery on a wall - business experts and developers modeling a process together as domain events on a timeline. It's deceptively simple, but something powerful happens when the people who know the questions meet the people who know the answers, exploring together what they thought they already understood.

In this session, you'll learn:

* Why modeling behavior over time reveals what data models and architecture diagrams hide
* How to surface hidden complexity before it surfaces in production
* The questions that unlock stuck conversations and expose risky assumptions
* Why starting messy gets you to clarity faster
* Practical techniques to run your first EventStorming session next week

You'll leave with a concrete approach for shared understanding that turns weeks of meetings into hours on a wall.

I Come to Bury AI, Not to Praise It

AI has become impossible to ignore in software development. It promises speed, leverage, and productivity. It also produces shallow designs, fragmented models, false confidence, and a lot of very convincing nonsense. For teams that care about long-term system health, shared understanding, and conceptual integrity, it is reasonable to ask whether AI is doing more harm than good. Skepticism is warranted, and caution is necessary.

But rather than treating AI as a miracle or a menace, this talk shares hard-won lessons from hands-on experience using AI in real design and development work. The core claim is simple: the real constraint has always been discovery, sense-making, and alignment. Used carelessly, AI amplifies the wrong things. Used deliberately, it can meaningfully support those deeper activities.

The session explores where AI helps and where it actively gets in the way. Topics include working with non-determinism instead of fighting it, designing workflows that assume failure rather than correctness, using AI to explore design alternatives without fragmenting understanding, and recognizing which problem spaces benefit from AI assistance and which do not. Along the way, the talk surfaces evergreen principles that still matter even as the tools change, including clarity of intent, semantic anchoring, and responsibility for decisions.

This is not a talk about tools, prompts, or hype. It is about judgment. Attendees will leave with a clearer mental model for when AI adds leverage, when it creates risk, and how to integrate it into serious design work without surrendering thinking, accountability, or coherence.

DDD by Example

Being both a way of thinking and a set of priorities, DDD can sometimes be perceived as overly abstract and amorphous. But the aim of DDD is accelerating development for teams dealing with domain complexity.

DDD is about shortening the time to value for customers, and doing this in a sustainable, repeatable manner. In this talk, you'll gain an understanding of what DDD looks like, why it matters, and what that might mean for you, your team, and your organization .

Context Mapping - hands on

In strategic design we seek to understand the deeper structure of our hidden sociotechnical landscape, especially the interaction of software systems and development teams.

Context mapping is a significant technique for discovering and communicating that understanding. It can be a key technique for enabling legacy application modernization, identifying and communicating team boundaries and responsibilities, and setting your teams up for success in their projects as you integrate with other contexts both internal and external to your organization.

In this hands-on lab, you learn key techniques for context mapping to drive success in your strategic design efforts. We'll show how context mapping connects to other techniques such as Big Picture EventStorming and enables both brownfield and greenfield application development.

n.b. We'll be using the ContextFlow OSS application (https://contextflow.virtualgenius.com) to map collaboratively and describe contexts, looking for emergent patterns, challenges, and strategies in our mapping.

Exploring Connascence

Derived from Latin, connascence means having been born together, applied to code it can indicate software components that have evolved to where changing one would
require the other to be modified in order to preserve overall system correctness.

In this hands-on session, we'll have fun exploring connascence as a lens for choosing the most effective refactorings, and as a tool for addressing interesting software modeling and design challenges.

No laptops necessary. We will likely be reading code, but nothing too difficult to understand. Come prepared to experiment, and learn!

Baking Domain Concepts Into Code - Hands On

Our goal is to make shared domain language and key domain concepts expressed in the code clearer and more explicit, resulting in code that is both malleable and easier to understand.

This will be a fun guided hands-on coding session demonstrating the knowledge loop of acquiring domain knowledge via EventStorming, using these new-found concepts to understand and refactor existing unclear application code, and then applying the coding insights back to our modeling.

We'll be intentionally looking for hidden domain concepts, naming them, moving them where they belong, and applying various tactical modeling patterns via TDD to express the domain model more clearly in code.

Come prepared to pair up with someone and read code together on a shared laptop (exercises available in Java, C#, Typescript, Ruby, Python, and Kotlin).

Code Samples are at https://github.com/paulrayner

Go to Repositories and choose the code sample repository you would like to work with based on your language preference:

• ddd_code_samples_java
• ddd_code_samples_csharp
• ddd_code_samples_ruby
• ddd_code_samples_typescript
• ddd_code_samples_python
• ddd_code_samples_kotlin

Access the code read-only through the browser if you prefer, or clone the repository locally and use your IDE.

Baking Domain Concepts Into Code

Our goal is to make shared domain language and key domain concepts expressed in the code clearer and more explicit, resulting in code that is both malleable and easier to understand.

This will be a fun live-coding session demonstrating the knowledge loop of acquiring domain knowledge via EventStorming, using these new-found concepts to understand and refactor existing unclear application code, and then applying the coding insights back to our modeling.

We'll be intentionally looking for hidden domain concepts, naming them, moving them where they belong, and applying various tactical modeling patterns via TDD to express the domain model more clearly in code.

Fighting the Invisible Enemy

Don Reinertsen says, “The enemy of flow is the invisible and unmeasured queues that undermine all aspects of product development performance.” But how can we fight an invisible enemy? Most development teams remain blissfully unaware of the negative impact of these invisible queues on their productivity and team flow, or how to deal with them effectively.

This talk focuses on modeling the presence and the negative impact of these invisible queues in the work of real teams. In this session, you’ll see how to use EventStorming to model and improve the current state of team flow, and context mapping to visualize a team's dependencies in order to understand the hidden organizational forces that hinder team productivity.

Speaker

Paul Rayner

Actions

Links

Area of Expertise

Sessions