Schedule

Keynote

Keynote

How can you fairly distribute thousands of taxi rides each month while respecting complex business rules and ensuring both performance and scalability? That’s the challenge we tackled with Winbook, our ride allocation engine built entirely in PHP with Symfony.

In this talk, I’ll take you behind the scenes of this production system, which handles a significant and growing volume of rides. We’ll explore how we leveraged Symfony components like Scheduler, Messenger, Notifier, and API Platform to build a robust, responsive, and scalable architecture.

We’ll cover:
* The business rules that drive ride allocation (such as local taxi licenses, driver behavior, etc.)
* The algorithmic choices made to ensure fairness and efficiency
* The technical challenges of implementing a real-time engine in PHP

This talk is for anyone who believes PHP can be both powerful and performant — and who enjoys seeing real-world code solving real-world problems.

Domain Driven Design focuses on modelling the domain logic and helps us to map the business requirements to our software. We'll discuss the terminology and take a look at what Domain Driven Design is and see how you use it to make software that meets the needs of its users. Most people seem to concentrate on the tactical patterns in DDD, but the strategic side is where the most benefit can be found. I will concentrate on the on these strategic considerations, particularly the importance of communication at all levels of the project so that by the end of this session you will be better positioned to create excellent, maintainable applications.

In this talk, I'll tell you how I built the raffler for our AmsterdamPHP meetups using WebSockets. We'll cover several real-time protocols and their limits and advantages.

Then, we'll move on to a whole lot of async PHP implementation using Ratchet for WebSockets. If you've ever wanted to learn how to build something for multiple users communicating in real time, this simple and fun use case is for you.

Package managers are critical infrastructure—and prime targets for supply chain attacks. This talk examines recent security incidents across npm, PyPI, and other ecosystems to understand what threats apply to Composer and Packagist.

We'll explore emerging security standards including SLSA, trusted publishing, build provenance attestations, and reproducible builds. You'll learn how GitHub Actions has become an attack vector, what organizations like OpenSSF and its Package Repository Working Group are doing, which improvements other language packaging ecosystems recently introduced and how two new projects funded by Germany's Sovereign Tech Agency will improve security for the PHP ecosystem.

Whether you maintain packages or just run composer install, you'll gain practical insights into supply chain security threats and the tools being built to address them.

Testing a unit of code that depends on other components often raises a critical question: when should you replace real dependencies with Test Stubs or Mock Objects, and when should you allow the code under test to collaborate with actual dependencies?

This session will demystify the effective use of stubs and mocks in unit testing. You'll gain a clear understanding of how to leverage PHPUnit's test double functionality to write robust tests, while also learning which features to avoid for better maintainability and reliability. By the end of this session, you'll be equipped with practical strategies to make informed decisions about dependency handling in your tests.

Are React, Vue, or even Hotwired still essential for creating modern websites and web applications?
New web projects, even those built using Symfony, tend to be systematically written as Single Page Apps. As a result, they contain a lot of JavaScript code, which often makes them unnecessarily slow and difficult to maintain. Their search engine optimization and indexing by robots powering AI chats can also be greatly degraded.

Thanks to modern CSS, however, the situation has changed: View Transitions and Speculation Rules now make it possible to achieve a UX and a perception of fluidity similar to that offered by the best SPAs, but using a “traditional” approach, without the need for JavaScript or the complexity it introduces.
In concrete terms, this means that it is once again possible to use our favorite framework and its companion Twig for what they excel at: generating server-side HTML, while maintaining excellent UI and UX quality.

During this talk, I will present the architecture of a modern Symfony application that does not depend (or depends very little) on JavaScript and is not an SPA. Then I will introduce a new Symfony UX component that takes advantage of this architecture, the Mercure protocol, and FrankenPHP to offer a feature prized by front-end developers: automatic reloading of views (while preserving states) during development.

Console is one of the most widely used Symfony components and ranks among the top 5 most downloaded PHP packages worldwide.

Used by essential tools such as Composer, PHPStan, and Psalm, as well as by most PHP frameworks, CMS, e-commerce platforms, and ultimately our end applications, the console is ubiquitous.

The more a package is used, the more difficult it is to evolve. The slightest bug fix on the Console can disrupt millions of users. Nevertheless, the component has been constantly improved thanks to the countless contributions it has received since its introduction in 2010, while remaining true to its promise of backward compatibility.

But it's time to give the Console a major facelift, not only to get rid of some limitations and other design issues, but also to open it up to new possibilities.
That's why a few key contributors have been working hard to redesign it.

It's available since Symfony 7.3, and will get even better in a future version.
Join me to rediscover the Console!

Wouldn't it be great if we can use our LLM to answer very specific questions? Wouldn't it be great to move away from a general purpose machine to something tailor made for me or my users? If we could stop asking questions like "What is the area of a sphere?" and more like:

- "What is the status on my last order?"
- "What are the total fees given to a supplier X?"
- "How many images have I uploaded this year?"

This talk will go over the MCP protocol, why we care and how to use it to create an AI service that is helpful.

Creating multi-tenant applications is a common task but there are many pitfalls such as using the messenger, scheduler, cache, and other Symfony components which are designed for a single tenant application by default. In this talk, we go through how you can extend these components using configs, PSRs, middleware, etc to make these components work in a multi-tenant fashion.

In this fast-paced talk, we'll walk through a complete life-cycle of working with a set of data, starting with a CSV file and ending with an AI-powered semantic search that's fast and beautiful.

To do this, we'll use Meilisearch, the same open source search engine that po
wers Symfony documentation. Meilisearch has recently added the ability to store vectors, making it easy to start with integrating AI into your application.

Symfony has some excellent tools for working with the data. We'll walk through them, starting with "symfony new --webapp my app" and then composer require a bunch of time-saving tools for Radid Application Development

* create an entity (make:entity -a)
* configure a console command (survos:make:command app:load)
* implement the load command, using CsvReader and ObjectMapper
* configure the api resource by tweaking some entity attributes so we'll have a readonly API endpoint
* make:admin:entity and make:admin:dashboard to create a way to view the imported data using EasyAdmin
* add some more entity attributes and create and configure a meili index
* import the data from doctrine to meilisearch
* configure a twig viewer (that renders in javascript!)

At this point we have a fast, powerful full-text search and filtering system that will be the envy of your peers. But there's more!

We'll setup an OpenAI account so we can create semantic vectors and store them, and add an embedder to meilisearch settings, and suddenly we have ai-powered semantic searcher.

Amazing, all of this happens with very few LOC (Lines of Code). Knowing what tools are available and how to configure them makes this possible, and the purpose of this talk is to demonstrate.

This talk will go into detail about how Vacatia leverages the Symfony Messenger component to power our tech stack's critical integration layer. We will look at how and why we use multiple message buses, tracing across multiple messages, chaining interdependent messages together, message batching, and more.

If you want to take your understanding of the messenger component to the next level, this talk is for you!

At first AI is a ton of buzzwords and hype, but how do we integrate AI in our existing products / software projects in a meaningful and realistic manner?
Let's have a look how Symfony AI enables us to bring AI-based or even agentic features, not only chatbots, into our PHP applications or scaled architecture.
If you are looking for input on how to approach AI, need ideas where to get started or find out what's realistic at first - let this talk be your inspiration!

Backend-rendered HTML is back. With the rise of Symfony UX, Twig is becoming more and more important. In this talk, we will look at how you can structure your Twig files without them becoming a mess, and what kind of tricks Twig offers to create reusable components. We'll explore how Symfony Form Theming works and why JavaScript frameworks like Hotwire Turbo with Stimulus and Tailwind make for a productive frontend stack for your next project.

CQRS is often associated with complex, over-engineered systems. But in real-life Symfony apps, it can be a pragmatic tool to structure features, simplify code and separate concerns - when used right.

In this talk, you’ll see:
- when and where CQRS brings real value in Symfony projects
- how to structure commands, handlers, queries and DTOs in a maintainable way
- practical integration with Symfony Messenger and validation
- what to avoid: CQRS anti-patterns that create friction, not clarity

I will prove that CQRS can be done right and fast, we'll live-code it! This session is ideal for teams who want to keep their architecture clean — without going full enterprise.

You knew API Platform back in version 2.6 and still think you know how to use it? Bad news: what you did yesterday is probably obsolete today.

Since version 3, and especially version 4 released last September, API Platform has completely transformed: new philosophy, new mechanisms, new developer experience. In short, the framework has grown — and your old habits might now work against you.

In this talk, we will:
- take stock of what version 4 really means,
- dissect the major changes (and what they imply in practice),
- list common mistakes made when coding “like before,”
- and give you the right reflexes to get the most out of the new version.

Whether you’re coming from v2.6 or just starting out, this talk will help you stop fighting the framework… and finally enjoy its full power.

Starting with PHP 8.4 you can implement lazy loading and proxy objects with native PHP functionality with little overhead and no code generation required. Both Doctrine and Symfony are historically using the proxy pattern with solutions and workarounds built in PHP. In this talk I will explain PHPs 8.4s native lazy objects and how it will be a game changer to both Doctrine and Symfony going forward.

Scaling PHP is about resilience and performance, not just traffic. This talk covers live demos of optimising the PHP runtime, tuning configs, and measuring FrankenPHP and PHP-FPM with tools like OpenMetrics, Grafana, and k6. Additionally, you’ll learn to avoid design flaws, architect for scalability, and gain the mindset to confidently scale PHP applications.

We've all been there: After a lot of discussion the team can still not agree on a given solution. A majority vote makes the decision, but that leaves team members unhappy and unsatisfied. What if I told you there is a way to make sure every team member is heard and will support the eventual team decision? In this talk, I will introduce the concept of sociocracy, a method for discussion and decision-making.

SQL has been around longer than most of us have been writing code—and it shows. Originally built for tidy tables and straightforward joins, it’s now being stretched to handle JSON documents, arrays, and even composite types. Meanwhile, so-called “NoSQL” databases are sneaking SQL in through the back door. In this talk, we’ll take a slightly ranty tour through the history of SQL, the rise of document databases like MongoDB and CouchDB, and the awkward state of modern query languages. If you’ve ever tried updating a nested JSONB field in MySQL and thought, “there has to be a better way”—this one’s for you.

In this talk, we will dissect the first Git commit by Linus Torvalds and uncover the powerful software design principles embedded in its earliest code. We will explore how Git’s choice of data structures (like immutable content-addressed blobs and trees) laid the foundation for reliability, correctness, and performance.

We will also highlight how Git is a brilliant embodiment of Unix philosophy: small, composable tools; reliance on the filesystem; text-based formats; and simplicity in interface with power in composition. Even in its minimal form, Git introduced key operations such as SHA-1 hashing, snapshot storage, and a filesystem-based object database that collectively reflect deep design clarity.

Modern AI features demand more than a quick API call. In this talk, you’ll learn the core patterns that make large-language models dependable, testable, and production-ready inside a Symfony stack, from prompt writing to agent orchestration, guardrails and observability.

Expect concise code snippets, a reference architecture, and concrete checklists you can apply on your next deploy. Ideal for engineers who have experimented with LLMs and now need a blueprint for shipping AI features the Symfony way.

Symfony is evolving and you may ask yourself whether your application can keep up. This presentation aims to show coding techniques and design patterns that will make future Symfony upgrades much easier, even if we don't know what the future holds!

Keynote