The Dark Side of MACH

MACH (Microservices-based, API-first, Cloud-native, and Headless) architectures are taking the e-commerce world by storm, promising a future of flexible, scalable, and fast-moving systems. But before you jump on board, it’s important to take a closer look at what you might be getting into. In this session, we’ll explore the often overlooked “dark side” of MACH—those hidden challenges that can catch you off guard if your team is coming from a traditional, monolithic background.

Rather than painting MACH as all sunshine and rainbows, we’ll talk openly about the tricky parts: juggling multiple microservices, handling complex data flows, and managing an evolving ecosystem of tools, platforms, and vendors. Drawing on guidance from the MACH Alliance (machalliance.org) and insights inspired by resources like Building Microservices by Sam Newman (O’Reilly, 2015) and Team Topologies by Matthew Skelton and Manuel Pais (IT Revolution, 2019), we’ll discuss how to spot the real needs of your current system, decide if MACH is right for you, and adopt best practices that keep complexity in check.

Join me for a frank, practical conversation about what it really takes to shift from monoliths to MACH. You’ll walk away with a clearer sense of how to manage the complexity, upskill your team, and shape a roadmap that builds on what’s essential—without getting lost in the hype.

a talk for people (within or outside the ecommerce domain) to get a reality check about MACH architectures beyond the hype. After this talk they should be able to understand if MACH is for them or not and get a little cookbook for the biggest challenges.

What tattoos and software projects have in common

In this session, we’ll explore why getting a tattoo and building software aren’t as different as they might seem. Both require vision, trust, and a steady hand—whether it’s ink hitting skin or code hitting production. We’ll look at how great artists and great developers share a respect for careful planning, a willingness to iterate, and the courage to commit. By the end, you’ll see that whether you’re holding a tattoo gun or a keyboard, the path to something remarkable is forged through patience, care, and embracing the unexpected. As a tattooed software guy i know of what i am speaking :)

5 common mistakes in DevOps strategies

Devops is one of the buzzwords of the recent years and thus many companies felt the urge to jump the hype train and implement what they considered to be Devops. In this talk i highlight 5 of the most common issues i met during my career when companies implemented their Devops strategy and explain why i consider them issues, and propose potential solutions.

Avoid the Ivory Tower of Software Architecture

In this talk I will tell you a story about an architect and a dev team wanting to develop a perfect product...the outcome is...well see and hear for yourself :)... In the talk I will point out common problems in the communication betweeen developers and architects, and show potential mitigations.

The art of quitting

Quitting. For most people this has a sound of failure and negativity, but in my talk i want to show why quitting is much more than this. In fact it is an essential tool for any founder, manager, engineer or poker player. I will show what makes quitting so hard and how we can mitigate the factors that let us quit too early or too late. Furthermore i will demonstrate how we can optimize our decisions if and/or when to quit at the right time. Quitting is an art. So let's practise it.

You Ain't Gonna Need It (Yet): An Ode to Moduliths

Your team debates microservices, Kubernetes clusters, and serverless—because everyone’s doing it. But what if the right choice is… none of them?
The “You Ain’t Gonna Need It” (YAGNI) principle isn’t about rejecting modern tools. It’s about rejecting guesses. Here’s the truth: Most projects evolve, and so should their architecture. Start simple. Scale deliberately.
In this talk, we’ll tackle:
Simplicity’s superpower: Why monoliths (or better: Moduliths!) still win for early-stage clarity
Evolutionary design: Letting requirements—not trends—dictate your tech stack
Complexity traps: Spotting overengineering red flags (e.g., “future-proofing” that never pays off)
When to pivot: Signals that it’s finally time to embrace those microservices
Real-world examples include a startup that scaled to 1M users on a “boring” monolith and an enterprise that saved $2M/year by deleting unused Kubernetes clusters. You’ll walk away with a filter for cutting through tech hype, aligning your architecture with today’s problems—and leaving tomorrow’s for tomorrow.

Why Your CEO should care about DORA Metrics

Picture this: Your CEO glances at a dashboard full of terms like “lead time” and “deployment frequency” and sees just numbers but no value? What if the CEO does not care for those metrics, as they do not produce apparent growth indicators?


But what if those metrics held the key to outmaneuvering competitors, retaining top talent, and weathering market storms?

DORA metrics aren’t engineering jargon—they’re your company’s vital signs. Think of them as a heartbeat monitor for agility: How fast do ideas become value? How quickly do teams recover from setbacks? Behind every data point lies a story about whether your organization can pivot, scale, or survive.

In this talk, we’ll dig into:
* The hidden language: Why lead time isn’t just about code, but market responsiveness
* From code to boardroom: Connecting deployment frequency to customer trust and revenue
* The resilience factor: How “time to restore” predicts long-term adaptability
* Proof, not theory: Lessons from DORA’s research and Accelerate’s game-changing insights

You’ll leave seeing DORA metrics as strategic tools, not technical trivia. We’ll map engineering efficiency to business outcomes—like how shaving hours off lead time can mean beating a competitor to launch, or why faster incident recovery correlates with stock price stability.

this talk is not just for DevOps engineers or sofware people. also executives and C level managers gain an important insight about how these metrics can make or break their business goals.

The Echidna Pattern: Scaling Platforms Without Losing Flexibility

Imagine building a platform that starts small—clean, efficient, and focused. But as adoption grows, external teams begin knocking: “Can we integrate Feature X?” “How about supporting Protocol Y?” Each request feels urgent, and saying “no” isn’t an option. Before long, your core platform risks becoming a tangled mess of custom integrations, slowing development to a crawl.

This is where the Echidna architecture shines. Inspired by the spiny mammal’s adaptive defenses, the pattern encourages wrapping your core platform with modular “spikes”—lightweight APIs and hooks that act as controlled entry points. Instead of bending your platform to meet every external demand, you let stakeholders plug into these spikes. Need to support a new API standard? Add a spike. A third-party tool integration? Another spike. The core remains untouched, stable, and fast.

In this talk, we’ll walk through:

* The inflection point: When scaling demands force teams to choose between speed and flexibility
* Spikes in action: How APIs and hooks create safe, scalable interaction layers
* Real-world lessons: Balancing stakeholder needs without technical debt
* The payoff: Faster iterations, happier developers, and a platform that evolves with its ecosystem

By the end, you’ll see how Echidna turns integration chaos into a structured, sustainable strategy—keeping your platform nimble, no matter how many requests come knocking.

Echidna Architecture is a pattern i came up with, helping several customers in keeping their platforms, or SaaS products in general, agile yet flexible to change