Workshops

Over two days, let’s explore how one can leverage Kubernetes to deploy their Symfony application.
After a couple of concept refreshes, we’ll start with a simple single pod and gradually improve it to incorporate more Kubernetes concepts, ultimately reaching an almost production-ready application.

Requirements:
- A basic knowledge and use of Docker and containers is required
- Be fluent with the use of Symfony, the command line, and local container management
- A basic knowledge of Kubernetes can be helpful, but is not required
- A local Kubernetes deployment accessible (minikube, Docker Desktop, etc)

Sulu 3.0 is more than just a headless or traditional CMS — it’s a flexible, Symfony-based platform designed for developers who want to integrate business logic into modern digital projects. In this hands-on session, you’ll learn how to move beyond structured content and implement domain-specific functionality tailored to real-world needs.

We’ll cover how to define custom entities, connect them seamlessly to Sulu’s powerful admin interface, expose them via API, and render them using a Twig-based frontend. Whether you’re building for clients or developing your own product, this workshop will show you how Sulu adapts to your business logic — not the other way around.

BDD is not just about tests - it’s about shared understanding and trust.

In this hands-on workshop, you’ll learn how to write high-value functional tests using Behaviour-Driven Development (BDD) techniques tailored for Symfony projects. We’ll start by turning business rules into human-readable Gherkin scenarios, then drive feature implementation with Behat - step by step, from failing spec to working Symfony code.

Whether you're working on APIs, back-office tools or user-facing systems, this workshop will teach you how to:
- collaborate with product stakeholders by modeling real-world behaviour
- integrate Behat into Symfony apps using modern PHP practices
- structure tests to survive business changes, not just framework upgrades
- use BDD to improve developer confidence and reduce testing overhead

This session is for PHP & Symfony developers who want to improve communication, increase test quality, and make Symfony applications that work - exactly as intended. Basic Symfony knowledge is expected, no previous BDD experience is required!

Have you ever wanted to learn about Test-Driven Development (TDD) but never had the chance to learn it properly?

Do you think TDD only slows you down?
You don't know what to do when getting stuck?
Attend this workshop and learn what TDD really is by practice, and add this methodology to your developer toolkit

In this workshop, you'll learn about:
- How to develop a complex feature from scratch by applying TDD using PHPUnit
- The anatomy of a clean test: Arrange, Act, & Assert.
- Going faster. Demystify the myth that TDD only slows you down.
- And many other useful tricks...

Progressive Web Apps (PWAs) bring native app-like experiences to the web. But how can we make them work seamlessly within a Symfony application without sacrificing accessibility, performance, SEO, or requiring deep JavaScript knowledge?

In this full-day workshop, we’ll build a real-world, installable, offline-ready application using Symfony, Symfony UX, and the PWA Bundle.

Step-by-step, participants will learn how to cache assets and routes and synchronize it in the background when connectivity is restored.

This workshop is 100% Symfony-centric: no React, no frontend frameworks, no deep JS required. Just Symfony, Stimulus, and modern web features made simple.

Object Oriented Programming (OOP) goes beyond the design of classes and interfaces. It includes a wide variety of concepts such as objects, entities, value objects, services, design models, SOLID principles, calisthenics, coupling, etc. Mastering OOP often requires several years of experience.

This workshop will help you to better understand all these concepts in order to write more maintainable, robust and testable object-oriented code. You will also discover techniques to reduce the complexity of your code and make your classes more specific and therefore simpler. You will also learn how to recognize and exploit the power of design models (factory, adapter, composite, decorator, mediator, strategy, etc.).

In the world of cybersecurity there is always a threat lurking. Waiting in the shadows for the perfect moment to strike. You can sit back and relax and hope for the best and react when it’s too late… or before they even think about making a move you can take the control over and see everything coming from miles away. In this session, you’ll dive deep into the art of threat modeling—an essential skill that allows you to anticipate risks, identify vulnerabilities, and develop a proactive defense strategy.

Mike will guide you through the process and show you why threat modeling is an offer you simply can’t refuse. You’ll learn how to analyze threats with precision, build effective threat scenarios and develop a mindset that stays one step ahead of the attackers. Ultimately you won’t only understand threat modeling—you’ll lead it with confidence.

Join Mike in the family business, hone your expertise and become the Godfather of Threat Modeling. In this game only the wise and the prepared will survive.

Take your PHP development to the next level by mastering customising two of the PHP ecosystem’s most powerful tools: PHPStan and Rector. Custom PHPStan rules let you enforce project-specific coding standards, catch domain-specific bugs, and even emulate features from other programming languages. Meanwhile, custom Rector rules help you automate and accelerate refactoring, keeping your codebase clean and maintainable.

Both tools follow a very similar process to create custom rules.
In this workshop, we’ll begin by walking through the creation of custom PHPStan rules, exploring how to tailor static analysis to your project's unique needs. Then, we’ll apply those same principles to crafting custom Rector rules, enabling automated refactoring tailored to your codebase.
By the end of the session, you’ll have the knowledge and practical skills to customise and extend these essential tools, empowering your team to write better code faster and with less effort.

This training is from the book "Symfony 7: The Fast Track" by Fabien Potencier. In 2 days, it will teach you how to build a Symfony application from A to Z using new practices and new components. For those who are new to Symfony, this training is an opportunity to discover capabilities of Symfony. For more experienced devs, it's an opportunity to know about and to discover the latest features and best practices.

We will build an application with all the infrastructure of modern apps: database, application and HTTP cache server, message bus for background processing, etc. We will start from the basics with the installation of a skeleton application, the creation of a data model and a "backoffice", then we will add screens for users, a security system to partition rights. We will enrich the business rules to send notifications, send emails, manage a publication workflow, etc. Finally, we will optimize the application for production through HTTP and application caches, through asset management (JS/CSS/images) and secrets management. To secure each step, we will write tests to guarantee non-regressions.

On the menu: Flex, DependencyInjection, Mailer, Workflow, Messenger, HttpClient, String, etc.

Doctrine ORM is the de facto standard ORM in Symfony applications. In recent years Doctrine DBAL & ORM have seen new major releases and with that breaking changes and updated recommendations on their usage. In this wokshop we want to introduce you to current best practices with Doctrine ORM and DBAL, as well as a deep dive of some of the more advanced features in Doctrine. In a series of exercises in a demo application we will explore these functionalities in practice.

While this workshop does not focus on modernization/upgrading to the most recent major versions, we will discuss some of the breaking changes and how to tackle them, if this is relevant to participants. Please note, that basic familiarity with Symfony & Doctrine are assumed. If you have no prior experience with Doctrine (or similar ORMs), we will try to accommodate as best as we can.

In this workshop we will be looking at tools, processes and a helpful mindset for refactoring projects.
Interestingly, some of the principles can also be applied to yourself and can help you to understand your inner "programming" - and its limits in your daily live.

Peter Dietrich, Software-Developer with 25 years of IT background and (future, in training) Gestalt-therapist will be taking you through a combined day of technical depths, debts, and the depths of your mind.

If you are willing to dive into technical details and also dare to look at yourself and the legacy code in your brain, this will be right for you.

With Symfony AI a new ecosystem for AI-integrated or agentic applications in PHP got launched and with this workshop we want to dive into the components, understand concepts and build different features from simple use-cases to agentic workflows. No prior knowledge other than Symfony and Docker is needed.

In this hands-on workshop, we’ll walk through the process of migrating from a traditional, layout-based content management system to Storyblok, a modern headless CMS, using Symfony and Symfony UX. Participants will learn how to break down legacy content into reusable, component-based structures and integrate them into a headless CMS while leveraging the flexibility of Symfony for backend development.

The workshop will cover key aspects like Domain-Driven Design (DDD) principles for organizing the content architecture, building components that can be easily managed within Storyblok, and handling SEO considerations during migration. By the end, you’ll have practical experience migrating content to Storyblok and building dynamic, SEO-friendly websites using Symfony and Symfony UX.

In this workshop, I’ll share practical knowledge we’ve developed at Printify over the past three years, where we transformed a large legacy Symfony project into a clean architecture and built two more greenfield applications following the same principles.

Thanks to Clean Architecture, our Symfony-based services became highly maintainable, adaptable to change, and remarkably stable, even during high-load periods like the Holiday Season.

But what is Clean Architecture?
It's a set of architectural patterns and principles designed to help you build software that is:
- maintainable in the long term,
- resilient to both technological and business change,
- scalable and cost-efficient,
- and structured in a way that enables productive team collaboration.

This workshop will be fully hands-on and Symfony-specific. We’ll work on a Symfony-based RealWorld Example Conduit app that has been intentionally written in a “framework way”. Together, we will:
- audit the application and identify key architectural pain points,
- design a Clean Architecture foundation tailored to Symfony's ecosystem,
- refactor the application incrementally and safely, applying principles such as Dependency Inversion and boundary separation.

By the end of the session, you'll have a clear roadmap for applying Clean Architecture principles to existing Symfony projects, regardless of how messy the starting point is.

Prerequisites:
- Basic understanding of SOLID principles (especially Dependency Inversion and Liskov Substitution),
- Experience with Symfony's DependencyInjection component,
- Docker is installed and a local PHP 8.3 environment.

Join me for a practical dive into architectural transformation and elevate the quality of your Symfony applications!