Lutz Huehnken
Builder of high-performing software engineering organizations.
Builder of high-performing software engineering organizations.
Hamburg, Germany
Actions
Lutz is the Head of Engineering Excellence at Upvest, a FinTech company in Berlin that aims to democratize investment. Previously, taking on roles with titles such as "Head of Engineering" or "Chief Architect", he lead the development of software for container shipping, online retailers, financial institutions, cruise ships' in-cabin entertainment, and others. His current focus is on event-driven architecture, highly available and scalable systems, domain-driven design, and the intersection of architecture and organization.
Lutz ist Head of Engineering Excellence bei Upvest, einem Berliner FinTech-Startup, das sich die Demokratisierung des Investierens zum Ziel gesetzt hat.
Zuvor war er als Architekt oder Engineering Manager an der Entwicklung von Software für Containerschiffe, Online-Händler, Finanzinstitute, Kreuzfahrtschiffe und andere beteiligt. Sein derzeitiger technischer Fokus liegt auf Event-Driven Architecture, die Microservices und Domain-Driven Design nutzt.
Area of Expertise
Topics
Building a Bank (with DDD, Microservices, and Autonomous Teams)
At Upvest, we build the software to manage the investments for millions of people from scratch. And with that, the organization to achieve this. We’d like to tell our story and share our learnings so far.
Being fully aware that, to quote the late Stefan Tilkov, “any particular architecture approach constrains organizational options”, we initially focused on designing an architecture that empowered autonomous product teams, allowing them to operate independently, make domain-driven decisions, and iterate rapidly on their domains.
As the product evolved, we encountered new challenges related to inter-team dependencies and flow efficiency. In response, we reviewed our teams’ topology, and optimized it for improved delivery flow and reducing bottlenecks.
Along with this, we recognized the need to adapt our architectural approach towards a more centralized model. This shift towards an Enabling Team and increased investment in Platform Engineering and DevEx aims to balance the benefits of autonomy with the need for standardized practices and governance in a regulated environment.
In this talk, we’ll share our learnings and strategies for each phase, exploring how we balanced agile principles with evolving architectural needs, and offering insights for teams navigating similar transformations.
Crafting Resilient Systems with Event-Driven Architecture
In the quest to build microservice systems that are elastic and resilient, Event-Driven Architecture (EDA) comes with the highest acclaims. But what does it actually mean? At what point is a system really event-driven, and what seperates it from one that's merely based on asynchronous messaging? How does event-driven architecture impact the service boundaries and design? And how to deal with about complex workflows and sagas? The presentation provides an overview of the principles and central concepts, show-casing some real life stories "from the trenches". It'll serve as a basis for an informed discussion about the potential and challenges of event-driven microservices.
Events, Workflows, Sagas: Complex Flows in Distributed Applications
In the development of microservices, sooner or later everyone comes across business processes that involve several services, and usually, in DDD terminology, several bounded contexts. Different approaches to implementing such processes lead to fundamentally changed outcomes. With consequences for the complexity, and thus for the operation and expandability of the system. Especially when event-driven architecture is applied, its asynchronous nature often collides with the desire for global control and synchronous responses. This can lead to "chimeras" that combine the "worst of both worlds".
In this talk, he will look at some principles of event-driven architecture. He'll explore how they relate to possible approaches to implementing complex processes. Special consideration will be given to boundaries of responsibility, and the relationship of processes and data.
A common pitfall in the event-driven world is simply copying workflows from a monolithic application. This can lead to hastily falling back on orchestration or workflow tools, and possibly to a "distributed monolith". How can we avoided this? The talk will introduce the idea of "micro-workflows" and explore how challenging and redesigning complex processes can lead to better systems. And finally, we'll ask the question: Should the Saga pattern be considered harmful?
Events! Events Everywhere!
Event-driven architecture is the pattern du jour in microservices world. But there's more to event-driven than just asynchronous communication. Let's talk semantics - what does "event" actually mean? Spoiler: Not everybody who uses the term means the same thing. It’s all too easy to get confused when people talk about Event Sourcing, Event Streaming, Event-Carried State Transfer, Notification Events, Domain Events, Fat Events, Event Storming and possibly yet other types of events.
And above all - why should you even bother with an event-driven architecture, what are the benefits?
Time for a proper clean-up. Let’s start with a clear and bounded definition of events, and from there explore the patterns of using events in micro- and macro-architecture, their benefits as well as challenges.
After the talk, participants will know what questions to ask if someone suggests to go event-driven, and will be able to assess the applicability of different approaches to their architectural tasks.
The Unreasonable Effectiveness of Events
For many, event-driven communication is often considered just an implementation detail. However, event-driven architecture has implications that reach far beyond the realm of asynchronous messaging. In this presentation, we will delve into many of these implications in detail. From delivery guarantees to promise theory, from designing event payloads to functional programming, from error handling to strategic domain-driven design - we will embark on a journey from seemingly minor details to the big picture.
Events, Workflows, Sagas? Keep Your Event-driven Architecture Sane.
When dealing with (micro-) services, we often face business processes that span multiple bounded contexts. Different ways of implementing this lead to massively divergent results, varying above all in complexity and manageability. Especially when applying Event-driven Architecture, its asynchronous nature clashes with a desire for global control and synchronous responses, sometimes leading to chimeras that combine the “worst of both worlds”.
This talk will establish some guiding principles, and use them to assess common approaches. It will explore the importance of responsibility boundaries, and of bringing the data to the behavior.
A common mistake in the event-driven world is to replicate monolith workflows, resulting in an excessive need for orchestration or workflow tooling, or (in the worst case) a “distributed monolith”. How can this be avoided? The talk will introduce the concept of microworkflows, and show how challenging and re-designing your processes will lead to better systems. And lastly, we will ask ourselves: Should the saga pattern be considered harmful?
Designing Reactive Systems with Event Storming
Building distributed, microservices based systems is also a challenge for the architect. To create better systems, we need to move our focus from the static properties of the domain, such as the data model, towards a dynamic view that is centered around business events. We will explore this from both a design and technical perspective.
Event Storming is taking the Domain-Driven Design community by, well, storm, and is successfully applied in different stages of the domain analysis and design process. We will look at Event Etorming as a modelling tool for microservices, and beyond that: How to translate an Event Storming model into a running system?
For this, we will deep dive into microservices architecture, the event-driven, asynchronous kind. This approach allows us to build scalable, resilient systems, or in other words, "reactive systems", with no Single Point of Failure or bottlenecks, and with an ability to self-heal to some extent.
At last we will bring the two worlds together and explore how the building blocks of Event Storming map to the concepts of event-driven systems.
Agile meets Architecture 2025 Sessionize Event Upcoming
Fast Flow Conf NL 2025 Sessionize Event Upcoming
iSAQB Software Architecture Gathering 2024 Sessionize Event
Developer Week '23 Sessionize Event
KanDDDinsky 2022 Sessionize Event
microXchg 2018 Sessionize Event
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top