Schedule

With coding agents moving from the IDE to the terminal, TUIs are having a renaissance. This session introduces the new Symfony Terminal Component, a TUI toolkit built from the ground up in PHP. We'll explore its architecture, the primitives it exposes, and how it makes building rich, interactive terminal interfaces possible in Symfony applications. Don't miss the pull request opening on stage!

Developing a Symfony application is fun. But manual tests can become tedious. So can debugging.
And it might also be too early in the design process to start writing tests.
But we can go in between: write new console commands.

With the latest Symfony Console updates, writing interactive commands has never been easier.
When used to test your code and your API design, they become a perfect debugging tool — for you, and for the developers who will later use your code.

Most Symfony applications buffer everything: database rows, serialized objects, entire JSON payloads, and only then send a response.
It works... until scale hits. Memory spikes, slow time-to-first-byte, crashing exports.

What if the real problem isn't performance, but buffering?

In this talk, we'll redesign the data flow of a Symfony app: from StreamedResponse and incremental JSON encoding to iterable data sources and Server-Sent Events.

You'll see how to emit data progressively, power live updates and long-running exports, and keep memory usage flat using tools Symfony already provides.

Stop building responses. Start streaming them!

PHP was long designed as a strictly stateless language: one request, one process, and then everything starts over.

FrankenPHP fundamentally changes this model by allowing long-running PHP workers to run directly within a Symfony application. Not to turn Symfony into a Node-style server, but to give it capabilities it has never had before.

In this talk, I introduce a new pattern: application sidekicks. These are specialized PHP workers, outside the HTTP lifecycle, that listen to their environment and reconfigure the application in real time; without polling, without approximate TTLs, and without redeployments.

Through concrete use cases (Redis Sentinel discovery, dynamic feature flags, etc.), we’ll see how to evolve an existing Symfony application while staying true to its principles.

The goal: to show that PHP can listen, react, and adapt in real time, without sacrificing its simplicity nor its traditional robustness.

Structuring an application around its domain rather than its framework is an old idea. Making it practical has sometimes felt like swimming against the current.

Thanks to the way Symfony 8 leverages modern PHP, this drastically changes. Recent evolutions in both the language and the framework align naturally with hexagonal thinking and tactical DDD patterns — no workarounds, no fighting the tools.

Join me as I wear both my Core Team member and DDD practitioner hats to give a pragmatic look at putting your business logic first, building applications that scale with your domain's complexity and remain maintainable as they grow, with Symfony's blessing.

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:
- how to approach CQRS, how to start implementing it without a hassle,
- when and where CQRS brings real value in Symfony projects,
- how to structure commands, handlers, queries and DTOs in an easy, 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, but also show you how you can expand your existing CQRS setup with new tools and libraries!

Discussing the benefits of Symfony as a framework for building successful software platforms. For for platform developers and the end user implementations. Pimcore as a platform migrated to Symfony in 2017. This enabled rapid improvement in the platform itself, and made end user installation and customization much simpler.

Key benefits have included:
- Doctrine
- Event and Event Listener architecture that allows easy extension without modifying platform code.
- A flexible configuration system that allows overriding source files when necessary.
- Robust messenger queue solutions.
- Bundle plattern.

This improves not just the platform code itself, but makes it much safer to customize in a way that allows future updates to be installed without having to rewrite customizations or break existing extensions.

The ExpressionLanguage component has been around for quite some time, and its usefulness is no longer to be proven. Many popular projects like OroCRM, Sylius, or Symfony itself use it.

This component can be seen as a PHP sandbox and is mainly used to set up an application by allowing for advanced configuration. It can also be used as an engine to implement business rules. Indeed, by using the component in this way, it is possible to let end users write configurations in an understandable, secure, and dynamic way.

This last aspect is really interesting and is what I want to explain.

During this talk, we will re-discover the ExpressionLanguage component by getting an overview of the conventional way it is used. Then, through a concrete example, we will see the real potential of this component. In an e-commerce context, we will create a system that allows administrators to write business rules. These rules will dynamically apply promotions.

At the end of the talk, we will know how to use the ExpressionLanguage component to let end users build their own business rules.

When inheriting an unmaintained legacy Symfony application, the real question is not “how to migrate”, but rather “where to start without breaking everything”.

In this talk, I share an honest retrospective of a Symfony migration carried out in production, on an aging application with limited documentation, few tests, and dependencies on components that are now obsolete.

Through this journey, I offer a reading of the battlefield: risk areas, false good ideas, and decisions that seem obvious on paper… but turn out to be dangerous once confronted with real-world constraints.

In particular, we will cover:
- How to step back from an unmaintained legacy codebase and identify the real problems
- The false good ideas we encountered during Symfony legacy migrations
- Common mistakes observed in the field, and how to avoid or mitigate them
- Small levers that make a big difference (order of actions, scope, tools, trade-offs)
- Key lessons learned from this migration: what we would do again, and what we would clearly avoid

This talk is aimed at developers working with inherited Symfony applications, often business-critical, who must move forward with limited visibility and very little room for error.

The goal is not to promote a perfect or universal method, but to share a real, lived experience, and provide attendees with concrete reference points, clarity, and practical tips they can apply to their own migrations.