In this episode of Stories on Facilitating Software Design and Architecture, we are joined by Paul Rayner, a seasoned consultant and expert in Domain-Driven Design and EventStorming. Paul shares a candid "war story" from his time as a tech lead that completely changed how he views leadership and influence. He recounts a well-intentioned refactoring session where he publicly critiqued a team member's code, aiming to teach better practices. The result was unexpected and severe: the developer felt shamed by the experience and quit shortly after.

This experience served as a harsh wake-up call about the "unseen authority" leaders wield and how easily the "blast radius" of our actions can damage team psychological safety, even when our motives are pure. Paul opens up about the "dominant blindness" that often affects technical leaders—where we fail to see how our rank amplifies our words, turning a simple suggestion into a crushing directive.

We dive deep into the power dynamics of technical leadership, exploring why simply having the "right" technical solution isn't enough. The conversation covers how to move from "fixing" people's work to facilitating their growth, why resistance should be treated as a valuable resource rather than an obstacle, and how methods like EventStorming can help externalize conflict.

Key Learning Points:

1. The Gap Between Intent and Impact: Why "I meant well" is never a sufficient excuse when a team member feels alienated or embarrassed by your actions.
2. Dominant Blindness: How leaders often underestimate the heavy weight of their rank and the pressure it puts on colleagues, especially when navigating contractor-employee dynamics.
3. Resistance is a Resource: Instead of pushing harder against pushback, view it as a signal to understand the underlying fears, threats, or misunderstandings driving the resistance.
4. Challenging Mental Models: Recognizing that when you criticize code, you are often challenging the deep-seated mental models and hard work of the person who wrote it.
5. Externalizing the Problem: How using visual tools like sticky notes (e.g., in EventStorming) can shift the focus from "me vs. you" to a collaborative discussion about the problem on the wall.

In software architecture, there is often a difficult tension between enforcing best practices and allowing teams the autonomy to learn through experience. One of the most common pitfalls in Event-Driven Architecture is the confusion between meaningful Domain Events and mere technical noise. When a team insists on the "easy way," is it better for an architect to block them or let them proceed into a potential disaster?.

In this episode, we are joined by Krisztina Hirth, Staff Engineer at PayFit and a longtime Virtual DDD co-organizer. Krisztina shares a candid story about a high-throughput team that insisted on publishing technical JSON logs rather than proper domain events because they didn't want to "mess up" their clean repository. Rather than forcing her will in a one-hour meeting, Krisztina made the calculated decision to let the tigers roam: she allowed the team to fail so they could learn the lesson empirically.

This conversation dives deep into the patience required for true socio-technical change. We explore why "going fast is often just wrong" and how a failure that generated 90% useless noise eventually led to a robust RFC process and a company-wide understanding of Domain-Driven Design. As Krisztina puts it, sometimes what looks like a mistake is actually just an "asynchronous domain modeling session" that takes eight months to complete.

3. Key Discussion Points

[00:01:00] The Trap of Technical Events: Krisztina recounts a debate with a team that viewed events as "technical JSON" sent to messaging, ignoring the business importance required for a true Domain Event.

[00:02:00] The "Clean Code" Fallacy: The team's resistance stemmed from a belief that adding domain logic would "mess up" their clean repository—an argument that left the architect speechless.

[00:03:00] Tigers vs. Mice: Utilizing a quote from George Box, Krisztina explains her decision to prioritize the long-term learning opportunity over the immediate technical correctness of a single service.

[00:04:00] The Cost of Noise: The team's implementation resulted in 90% of their published messages being filtered out as noise by other teams, highlighting the waste of "easy" implementation.

[00:06:00] From Failure to Process: How the team owned their mistake, presented their learnings to the company, and helped establish a standardized LFC (RFC) process for defining future events.

[00:17:00] Asynchronous Domain Modeling: Reframing a long-term failure and recovery period as a necessary, extended modeling session that aligns the team with the architecture.

[00:15:00] The Goal isn't "Being Right": A heuristic for architects—if your primary goal is to prove you are right, you are likely wrong. The goal must be shared understanding and doability.

In this episode of "Stories of Software Architecture and Design," hosts Kenny (Baas) Schwegler and Andrea Magnorsky welcome back guests Elena and Pete to discuss the challenges of managing team autonomy when an architect disagrees with a decision.

Pete, who discussed this topic at QCon, shares his perspective on dealing with decisions made by teams that he felt were incorrect.

• Architect's Dilemma and Self-Reflection: Pete shared his challenge when teams made decisions he disagreed with, stressing the need for the architect to first reflect on whether their own feedback was persuasive and to remove emotional attachment from the outcome.
• Building Accountability and Skills: The discussion covered the difficulty when teams lack the "harder skills" for questioning , emphasizing that Architecture Principles are key for guidance, especially regarding cost , and that the architects' role is critical for supporting teams to build accountability and trust.
• Decisions Across Boundaries: The team tackled the issue of decisions affecting multiple teams (i.e., "context wars") , confirming that a key tool is the Context Map (from DDD) to promote autonomy and that dealing with this requires facilitating communication.
• Granularity of ADRs: A challenge was the differing frequency and size of Architecture Decision Records (ADRs) across teams. The consensus was to encourage teams to write ADRs, even small ones that don't need the formal advice forum , as long as they find their right flow and document impactful decisions.