Schedule

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.

No buzzwords, no magic solutions, just proven techniques for setting up AI code assistants that actually help. We'll cover prompt and context engineering strategies that work with Symfony patterns, configure your development environment for maximum productivity, and deploy intelligently to Upsun. Live coding included.

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.

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.

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.

In microservice or event-driven architectures you might find yourself having to solve issues which are simple when working with monolithic applications. One of these challenges is distributed transactions, i.e., performing an action across multiple services can be safely reversed when something fails along the call chain. The Saga pattern is an established approach to make this happen. Let's have a look at what it is, how we can implement it in a modern Symfony application and when we might want to avoid it.

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.

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!

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.

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.

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.

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!

AI features are rapidly becoming a core part of many modern web applications, including those built with frameworks like Symfony. As technical writers, our role goes beyond simply explaining how things work - we help build user trust by documenting AI features with transparency and ethical care.

In this talk, I’ll share practical approaches to crafting AI documentation that honestly communicates AI’s capabilities and limitations, highlights bias and privacy concerns, and empowers users to engage responsibly with intelligent systems. Drawing from real-world examples and best practices, I’ll show how to write docs that promote clarity, fairness, and user confidence across diverse technical audiences.

Whether you’re working with Symfony or other tech stacks, this session will equip you to evolve your documentation for the AI era - helping teams deliver not just functional products, but ethical ones.

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?

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.

Composer is the go-to tool for distributing Symfony applications—but when your target audience includes end users or less technical stakeholders, the CLI can be a barrier. What if installing a Symfony app was as simple as uploading a single file to your server and opening it in a browser? In this talk, I'll walk you through how we use Symfony to install Symfony applications packaged as a single, self-contained PHP file with just a web interface in the browser.

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.

With the last chapter, we explored the extraordinary contributions of women to the history of computer science. But did you know that was just the tip of the iceberg? After diving deeper into this fascinating subject, I’ve uncovered even more incredible stories to share.

What about the pioneer behind assembly language? Or the creator of the STP, without which the World Wide Web might never have existed? And what about the brilliant mind behind the ARM architecture?

Join me as we journey once again into the history of computer science to uncover the remarkable achievements of even more amazing women.

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.

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!

Paul presented Dagger to us at Vienna last year, and it completely blew our minds away!
Dagger is the new way of writing CI pipelines (by the creator of Docker).

Let's see how we leveraged it to:
* Run tests locally exactly as they're executed in your CI (no more "My tests pass locally but not in the CI").
* Write only pure PHP and get rid of most of the YAML bloat.
* Effortlessly execute a test matrix for multiple versions of Symfony and PHP.

Naturally, we used it in `SensioLabs/GotenbergBundle`, a real-world use case.
Join us and learn how to empower PHP for your CI and eliminate the YAML!

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.

Go beyond classic automation and discover the intelligent, secure CI/CD pipeline of the future. This session uses a concrete, containerized Symfony application to demonstrate the key pillars of a next-generation software delivery lifecycle. We will explore how to drive the entire pipeline with GitOps as the single source of truth, how to integrate "Zero-Trust" security at every stage (SAST, DAST, secrets), how to leverage AI to predict regressions and optimize deployments, how to unify DevOps and MLOps to manage both application and model lifecycles, and how to build a native multi-cloud architecture using Kubernetes and Kustomize.

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.

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.

After presenting Gally last year, this time we will take a technical look at its design. We will show how Symfony enables us to abstract search configuration, automatically generate an API through stitching, and integrate modern approaches such as vector search and conversational search to leverage AI. This talk will share our experience on how to turn Symfony into a solid foundation for building a discovery product that is robust, modular, and future-oriented.

I'm not going to tell you to rebuild your application in Rust. At all. I love Symfony (and PHP), we all do. But there are times when we hit a performance roadblock. Or run out of memory. Maybe even both.

In this talk, we’ll replace part of our logic with a native helper using PHP’s FFI and Rust. We’ll explore performance gains, show practical implementation steps, and discuss when native code makes sense. And finally, I’ll share a skeleton project so you can start experimenting in tonight.

Large Language Models are powerful, but making them useful in enterprise contexts requires more than just prompts. In this session, we’ll explore how Clean Architecture principles enable the design of cloud-agnostic AI agents, with RAG as a guiding use case, ensuring portability, compliance, and sovereignty without sacrificing innovation.

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.

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.

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.

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!

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.

Discover how semantic search powered by Retrieval-Augmented Generation (RAG) and open-source LLMs can transform information retrieval in complex web applications. I’ll share practical insights from building a semantic search PoC for the automotive industry, covering the architecture, lessons learned, and how to bridge the gap between keyword and intent-based search.

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.

Keynote