Schedule

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!

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.

Keynote

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.

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!

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.

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.

Keynote

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.

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.

In our pursuit of delivering high-quality code, we increasingly rely on automated tools like PHPUnit, PHPStan, Code-Fixer, Deptrac, and most recently AI. While following the best practices established by these tools' creators is valuable, there's a fine line between effective usage and overreliance. Drawing from our experience as a software vendor, I'll share real-world challenges we face in managing code quality tools. Through practical examples, I'll demonstrate situations where these tools can become counterproductive and present strategies for finding the right balance. Join me in examining whether our dedication to automated quality control might sometimes do more harm than good. Let's retrospect and answer the following question: are WE actually the sharpest (quality) tool in the shed?

WordPress powers a vast portion of the web, and Symfony provides a robust framework for building complex applications. What if you didn't have to choose between them? This talk dives deep into the practical strategies for integrating these two powerful PHP platforms.

We'll explore various tried-and-tested methods, from embedding a Symfony application within WordPress to running WordPress inside a Symfony application. We'll also cover advanced techniques like WordPress code manipulation to create a truly unified application.

Whether you're looking to enhance a legacy WordPress site with modern Symfony framework or leverage Symfony features like forms, Twig, Live Components UX-friendly admin panel for a Symfony project, this session will provide you with a clear roadmap, best practices, and real-world examples to help you build more powerful and flexible web applications.

The Symfony ecosystem is constantly evolving to ease developer experience and optimize application efficiency. New Symfony components, such as JSON Streamer, are at the forefront of this evolution, raising the bar for modern web application performance.

We'll take a modern application built with API Platform and supercharge it, showcasing how this new component, along with the efficiency of FrankenPHP in worker mode, can be used to achieve significant performance gains. This talk will provide concrete benchmarks and practical use cases, demonstrating how you can build faster, more efficient applications.

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.

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.

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.

Another way to make life much easier for content and marketing teams is to provide them with a Domain-Specific Language to customise the system. The Symfony ExpressionLanguage component can be useful not only for developers, but also for those who use the system in the UI.

In this presentation, we will look at how to use this component to create an easy to use and understand DSL that can be used for content management and application customisation.

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.

While most PHP applications rely on traditional row-oriented databases, many modern applications require processing massive amounts of data for analytics, logging, and metrics – areas where conventional databases struggle. This becomes even more apparent when you need real-time performance at scale.

ClickHouse is a powerful column-oriented database that can save you significant time when aggregating data in real-time, all without leaving the comfort of your technology stack.

In this talk we'll explore :
- Why column-oriented databases are game-changers for analytical workloads
- How to integrate ClickHouse with Symfony applications using recommended practices
- Real-world architecture patterns that effectively combine traditional databases with ClickHouse
- How to deploy ClickHouse with just a few lines of code
- Key ClickHouse features for building real-time dashboards
- Concrete aggregation examples with benchmarks comparing ClickHouse to other solutions

We'll also cover advanced features like cold storage, replication, and practical optimization tricks learned from production experience.

Whether you're working with e-commerce applications, logs, user events, IoT data, or business metrics, this talk will equip you with the knowledge to implement ClickHouse as a powerful addition to your PHP development toolkit.