Conference Report #

Craft Conference is a two-day, festival-like tech event about software delivery craft. In 2023 it took place on May 18–19 in Budapest, Hungary, and you could attend both live and virtual. The conference combines talk sessions, workshops, and the CraftHack hackathon.

I joined the main conference days and focused mostly on architecture, testing, and platform topics. The speaker lineup was strong, with well-known names like Sam Newman, Manuel Pais, Aslam Khan, and Michael Nygard, plus many other speakers from different companies and backgrounds.

Venue and overall vibe #

The venue is the old railway museum in Budapest. It has a special industrial atmosphere: big halls, historic trains outside, and multiple stages spread across the area. It really feels different from a typical hotel conference.

A few practical notes:

• The location is a bit outside the city center. It was reachable, but you should plan some travel time.
• Day 1 was cold and rainy, which made the outdoor parts less fun.
• Some stages were in tents. These were a bit cold and you could hear noise from nearby talks, so it depended on where you sat.
• In breaks you could even ride a small train around the museum grounds, which is a nice “conference novelty”.

Food was good (standard options plus a grill stand), but lunch lines got long. Coffee was available as filter coffee and there was also a barista corner, with the expected queue.

Sponsors and recruiting booths were visible (for example BlackRock, Tesco, Siemens). Before many talks there was a short sponsor clip, which started to repeat quickly.

The after party included four free drinks per attendee. For me the mood was okay but not great, and the party was already quite empty around 22:00.

Keynotes and main takeaways #

Sam Newman – “You Keep Saying That Word” #

Sam Newman opened the conference with a talk about how we use words like “sync” and “async” in distributed systems. His main point: the question “is it synchronous or asynchronous?” is often not useful, because the terms are overloaded.

Things I wrote down:

• It helps more to talk about request/response vs event-driven communication.
• Request/response can be implemented in a blocking or non-blocking way, and it can still be “async” in different meanings.
• “Async does not necessarily mean slower.”
• Even “non-blocking” calls can end up blocking somewhere else.
• Language matters: teams should check they mean the same thing when they say “async”.

This keynote was a good reminder that architecture discussions often fail because of unclear definitions, not because people disagree on the goal.

Aslam Khan – “Property-Based Thinking” #

Aslam Khan closed Day 1 with a keynote on property-based testing and, more importantly, property-based thinking.

My takeaways:

• Instead of testing only examples (“given input X, expect output Y”), you look for general properties that should always hold.
• This can lead to better test coverage and can reveal edge cases you didn’t think about.
• It also changes how you design software, because you start thinking in invariants and behavior rules.

He referenced the QuickCheck tradition from Haskell, but the bigger message worked for any language.

Manuel Pais – “The Future of Platforms” #

Manuel Pais opened Day 2 with a keynote about internal platforms (he is also known from Team Topologies). His definition and examples were very practical.

Notes I kept:

• A digital platform is a foundation of self-service APIs, tools, services, knowledge, and support—treated like an internal product.
• Platforms are not only “developer platforms”. He gave examples like compliance platforms, legal platforms, and even leadership platforms.
• Autonomy is not “everyone does what they want”; it is agency with safety inside shared and encoded values.

This talk matched a trend I saw across the conference: scaling works better when you reduce cognitive load and make the “good path” easy.

Sessions I liked (besides the keynotes) #

Martin Thwaites – “Building Operable Software with TDD (but not the way you think)” #

This was one of my most interesting testing talks. The idea was to connect TDD with operability: software that runs well in production and is easy to debug.

Key points:

• “Operable software” is more than app code. It includes tests, pipelines, infrastructure, and observability.
• Outside-in testing (starting from the external API / user perspective) can reduce brittle tests and keep focus on real behavior.
• Some things are still hard to test with classic approaches (caches, performance, cloud behavior, internal state changes).
• He showed how OpenTelemetry tracing can help test certain invariants and characteristics by checking spans and traces, not just function outputs.

For me the main idea was: observability is not only a production topic. You can use it during development to understand how the system behaves.

Joseph Pelrine – “Beyond the buzzword: a psychologist’s thoughts on psychological safety” #

Joseph Pelrine challenged the common “psychological safety” narrative. One point that stayed with me: the term is used a lot, but the definition is often unclear, and some popular references are shaky.

A practical observation I liked:

• Look for “bids for connection” in a team (small attempts to connect), and see if they are met positively. This is a more observable signal than repeating the buzzword in surveys.

David Leitner – “The Art of Architecting for Scale” #

This talk was about scaling systems with a focus on resilience and availability.

My main takeaway:

• You should design behavior based on the availability of dependencies. If a dependent service is not highly available, you may need patterns like queuing, retries, or delayed processing instead of immediate failure.

It also connected well with the general “avoid distributed monoliths” topic that appeared in several sessions.

Niklas Gustavsson – Spotify micro component architecture (data-driven study) #

This talk was packed with numbers and was a nice reality check on modularity at scale.

Notes:

• Spotify has around 10k micro components, with about 3k lines of code median size (as shown in the talk).
• Many squads, many deployments per day, and the dependency graph tends to become “scale-free”.
• A point I found important: dependency structure and team collaboration are connected, but not identical. You can measure both, and you should be careful how you interpret the metrics.

Michael Nygard – “Lessons learned building developer platforms” #

Michael Nygard spoke about developer platforms and the traps you can fall into.

Two lines I wrote down because they are very usable:

• “Enable adoption of practice first, then the platform.”
• “Any decision not enforced by automation is an argument you’ve chosen to have again in the future.”

He also referenced Hyrum’s Law: if enough people use your API, they will depend on every observable behavior, promised or not.

Themes I noticed across the conference #

• Clear boundaries matter more than the “monolith vs microservices” debate. The hype is calmer now, and many talks were more balanced.
• Testing is moving from “more tests” to “smarter tests”: properties, outside-in, and better local developer experience.
• Platforms and internal products are a big topic, often linked to cognitive load and team autonomy.
• Words and definitions are not a small detail. Many architecture problems start with people using the same terms with different meanings.

Workshops and hackathon #

Around the main conference days there were workshops (before and after). Topics ranged from tech leadership to OpenTelemetry and agile transformation models. I personally only attended the conference days, so I can’t share first-hand feedback on the workshops.

The CraftHack hackathon ran in parallel, and it added to the “festival” feel. Even if you don’t join, it is interesting to see the pitches and the energy from the teams.

Final thoughts #

Craft Conference 2023 is a good option if you want broad exposure to software delivery topics and a mix of architecture, testing, leadership, and platforms. The main stage talks were consistently strong.

For me the downside of the format is also the selling point: there is a lot of breadth, sometimes at the cost of depth. With fewer parallel tracks, the overall experience might become more focused (but of course you would lose some variety).