Opening Keynote (🇺🇸)

This talk topic will be announced shortly.

API Platform : Le Hub Sémantique qu’on mérite (et comment piloter du Go avec) (🇫🇷)

Faire du microservice, c’est souvent troquer une stack cohérente contre une armée de petits services qui parlent tous un dialecte potentiellement différent. On choisit Go pour la perf brute (et parce que c’est cool), mais on finit avec des APIs “plates” qui ont perdu toute la richesse sémantique qu’on aime tant dans l’écosystème PHP.

L’idée de ce talk ? Arrêter de forcer Go à faire du Web élégant et arrêter de forcer PHP à faire du calcul ultra-critique. Je vous propose d’explorer un pattern que j’affectionne : API Platform utilisé comme un “Semantic Hub”. On va voir comment poser API Platform en frontal pour garantir le contrat (JSON-LD, Hydra, OpenAPI) et déléguer le “sale boulot” à des microservices derrière.

Au menu de cette session :

• Pourquoi API Platform est la meilleure gateway du marché pour unifier votre SI.
• Comment Jane PHP et AutoMapper sauvent vos State Providers en générant des clients type-safe en deux commandes.
• Comment on “court-circuite” l’ORM pour mapper des DTOs sans perdre les bénéfices du framework.
• Cas pratique : On prendra des exemples dans la monétique pour illustrer comment gérer des flux transactionnels sans casser la sémantique.
• Vibe Coding & IA : Pourquoi une API sémantique est le seul moyen de ne pas rendre vos futurs agents IA complètement fous.

On ne parlera pas de futur, mais de pragmatisme : comment garder la maîtrise de son contrat d’interface quand le backend part dans tous les sens.

Building a framework by accident (🇺🇸)

For the past three years — and by total accident — I’ve had the chance to work on the most impactful project of my programming career.

In this talk, I want to walk you through how that happened, and share the many lessons I learned along the way. We’ll talk about the power of open source, designing modern software and dive into some of Tempest’s features.

Building Desktop Apps with FrankenPHP (🇺🇸)

HP on the desktop sounds like a bad idea. Until it works.

FrankenPHP isn’t just a Caddy module, it’s a Go library you can embed anywhere. FrankenWails combines it with Wails, Go’s answer to Electron. The result: native desktop apps where PHP handles the backend, HTML/CSS/JS handles the UI, and Go is the glue. No Node.js, no Electron, no server. Just a single binary.

In this talk, we’ll look at how PHP, Go, and the frontend communicate inside a single process, how to expose native menus, dialogs, and system tray to PHP, and how to distribute your app, either as a single binary or by packaging your PHP code as a PHAR archive that the runtime can load directly.

We’ll walk through the code, run live demos, and end with a working desktop app that you’d never guess isn’t native. Don’t worry if you don’t know Go, if you know PHP it’ll feel very familiar.

Building Resilient Architecture : Event-Driven Design with API Platform, Messenger & Redis (🇺🇸)

Modern enterprise systems can’t afford to be fragile. When a critical downstream service is slow, an ERP takes 3 seconds to respond, or traffic spikes unexpectedly, your API needs to keep serving gracefully.

In this talk, I’ll share hard-won lessons from a real-world migration: replacing a legacy BizTalk middleware layer with a Symfony/API Platform application that talks directly to SAP via RFC, processes orders asynchronously through Messenger, and uses Redis both as a cache layer and a message transport.

We’ll cover how to design API Platform resources that respond instantly by deferring heavy work to Messenger workers, how to implement smart Redis caching strategies that protect your backend from stampedes, and how to structure your message handlers for retry, failure isolation, and observability.

We’ll also look at the tricky parts nobody warns you about : backward compatibility with legacy REST consumers, cache invalidation timing, and what happens when your SAP connection pool runs dry on a Monday morning.

No slides full of theory. This is a production architecture, running today, handling real orders for a manufacturing company. You’ll leave with a concrete, production-tested architecture pattern you can apply to any project where reliability matters more than cleverness.

DDD x API Platform: 4 years later (🇺🇸)

In 2022, we explored how Domain-Driven Design principles could be applied with API Platform 3, which helped making API Platform better.

Four years later, API Platform 4, PHP 8.5 and Symfony 8 have reshaped the landscape. Time to revisit the topic! API Platform is the most productive framework for building web APIs. Its conventions and Doctrine integration make it incredibly fast to get started. But when business complexity grows, that simplicity slowly becomes a constraint.

This talk picks up where the first edition left off. With its revamped resource model, state processors/providers and filters system, API Platform 4 makes it easier than ever to structure applications around your domain. But the real value of DDD shows when the framework’s defaults no longer fit: heavy data processing, large dataset streaming powered by Symfony’s JsonStreamer - the kind of scenarios where you need to step beyond the built-in conventions.

Hexagonal architecture, message-oriented design, clear boundaries between domain and infrastructure: we’ll show how these patterns translate concretely into an API Platform 4 project, both when you stay on the rails and when you deliberately leave them.

De GPT-3 aux agents : 5 ans d’évolution d’une stack LLM en PHP (🇫🇷)

En 2021, l’effet “magique” : nous intégrons GPT-3 à notre SaaS SEO (stack Symfony/API Platform). Un simple appel à une API, un prompt, et nous avons des suggestions de titres dans notre application.

Deux ans plus tard, l’effet magique s’estompe. Nous maintenons des dizaines de “générateurs”. L’architecture (1 classe = 1 prompt) est devenue une usine à gaz, difficile à maintenir ou à faire évoluer.

2024 : Le besoin d’intégrer Claude expose notre dépendance technique. Nous devons intégrer un second provider dans une architecture 100% OpenAI. Première refonte : une abstraction multi-provider avec fallback. Changer de LLM devient une ligne de config. Mais les nouvelles features exigent d’aller plus loin. Le besoin émerge de gérer le streaming, de maintenir des échanges LLM de plusieurs minutes, et d’orchestrer des prompts secondaires. Deuxième transformation : nous passons à un système d’agent asynchrone. L’agent peut utiliser des “tools” (connectés à notre stack ou des API tierces) pour exécuter ces workflows complexes, tout en gardant la performance comme priorité. Cette nouvelle stack a soulevé des défis majeurs en PHP : fiabilisation de l’exécution, observabilité de workflows complexes, et gestion de la parallélisation/asynchronisme des “tools” sans async/await natif.

Aujourd’hui, notre système (templates versionnés, observabilité complète, error recovery) gère environ 40 000 requêtes/jour. Ce talk est le REX de 5 ans de choix d’archi, de patterns, et de belles problématiques pour faire tourner des LLMs en production… avec PHP.

De zéro à la prod : le déploiement Symfony enfin accessible aux débutant·es (🇫🇷)

Beaucoup de devs Symfony savent construire une application, mais bloquent au moment de la mise en ligne. Le fossé entre le local et la production (serveur, conteneurs, certificats) reste immense pour les novices.

Dans cette conférence, je vous présente FrankenDeploy, un CLI open source permettant de déployer une application Symfony sur n’importe quel VPS en une seule commande. Nous aborderons :

• Les problématiques de déploiement pour les débutant·es ;
• Les choix techniques et les coulisses de l’outil (détection auto, orchestration, rollback) ;
• Les défis rencontrés lors de sa conception.

L’objectif est de montrer qu’un déploiement serein ne doit plus être réservé aux expert·s et d’encourager la création d’outils rendant l’écosystème Symfony plus accessible.

Des APIs sécurisées sans perdre la tête (🇫🇷)

La sécurisation d’une API n’a pas toujours été facile, mais ces dernières années, l’authentification a été standardisée. Des solutions modernes et robustes ont vu le jour.

Vous avez peut-être rencontré les mots-clés Oauth2, OIDC, JWT, Rate Limiting au cours des dernières années. Ce sont les technologies qui sont les fondations de la sécurisation de vos API. Mais nous irons plus loin, avec des outils comme Keycloak et de toutes nouvelles fonctionnalités de Symfony, qui nous éviteront d’avoir à implémenter des protocoles complexes en PHP.

En tant que développeur d’API, vous découvrirez comment améliorer la sécurité de votre API de façon moderne, en utilisant les bons outils. En tant que consommateur d’API, vous découvrirez comment interagir en toute sécurité avec des API externes.

Que vous développiez votre propre API ou que vous soyez client d’une API externe, venez apprendre à travailler en toute sécurité sans perdre la tête !

Extension 101 : Invisibles mais indispensables (🇫🇷)

Vous avez sûrement déjà croisé des noms comme ext-json, ext-mbstring, ou ext-libxml dans vos fichiers composer.json, sans forcément comprendre ce qu’ils font — à part qu’ils sont indispensables au bon fonctionnement de vos applications.

Mais ces packages ne viennent pas de Packagist : ce sont des extensions PHP, des modules natifs qui enrichissent le langage avec des fonctionnalités supplémentaires et souvent essentielles.

C’est l’heure de démystifier ces fameuses extensions : à quoi elles servent, comment elles fonctionnent, et surtout, comment créer la vôtre ! L’occasion de (re)découvrir PHP sous un nouvel angle, et de donner un peu de sens à ces lignes parfois obscures dans vos composer.json.

From Zend Framework 1 to API Platform 4: Migration recipe (🇺🇸)

Migrating a large, complex legacy application is never just a technical challenge, it’s a matter of finding the right equations between business constraints, team capacity, and long-term maintainability.

This talk is a real-world experience report of an ongoing migration from Zend Framework 1 to API Platform 4, Doctrine 3, Symfony 8, and PHP 8.5. A journey that involves turning unstructured payloads into proper REST APIs leveraging the principles of linked data, progressively migrating public endpoints without breaking consumers, and making the most of the latest framework features along the way.

We’ll cover the motivations behind such a migration, the constraints that shaped our approach, and the trade-offs we had to make. We’ll also share how AI tooling has become a practical ally in tackling tech debt and legacy code at scale - not as a silver bullet, but as a real productivity lever when used in the right context, like tackling 10 years of technical debt in less than 6 months.

Whether you’re maintaining a big ball of mud or planning your own migration path, this talk will give you concrete strategies and honest lessons learned from the trenches.

HTTP Headers: The First Line of Defense for APIs and Frontends (🇺🇸)

Server-side security like authentication and data validation is crucial, but we often overlook the browser’s role as the final line of defense. HTTP security headers act as firewall rules for the client by dictating which resources are trusted and how they should be isolated.

In this session, we will explore the essential headers every modern application should ship, including CSP, CORS, and advanced isolation policies like COOP and COEP. Using concrete examples with Symfony and API Platform, you will learn how to build a robust security policy that protects your users against XSS, clickjacking, and side-channel attacks.

Is FrankenPHP the Fastest Way to Run PHP? (🇺🇸)

What are the performance benefits and implications of using FrankenPHP over PHP with FPM, Apache2, or Swoole exactly?

In this talk Benjamin will look at FrankenPHP from all angles, classic and worker mode, explain and contrast them with other solutions and provide some numbers from benchmarks and real production use-cases. In the end you should leave with a better understanding of the performance gains from running your first FrankenPHP deployment.

Opening Keynote (🇺🇸)

This talk topic will be announced shortly.

L’exception qui confirme la règle (🇫🇷)

“Everything fails all the time.” — une vérité universelle, aussi valable en développement. Un appel API échoue, une requête SQL déraille… et soudain, une Exception surgit un peu comme un Pokémon sauvage. À ce moment-là, deux choix s’offrent à nous :

• L’attraper avec une Hyper Ball (et la logguer soigneusement dans notre Pokédex)
• La laisser filer, au risque qu’elle réapparaisse au pire moment.

Les exceptions sont bien plus qu’un simple mécanisme d’erreur : c’est un outil puissant que PHP met à notre disposition pour construire des applications plus sûres, plus robustes et plus observables.

Dans cette conférence, nous verrons comment réagir face à une exception, les bonnes pratiques de structuration en PHP, les outils qu’offrent Symfony pour les intercepter, les transformer et les logguer efficacement.

Love Humans, Use AI (🇺🇸)

The developer role is shifting. We specify, delegate, refine, and orchestrate more than we type actual lines of code. And honestly? It’s incredible. But it’s also… weird? Because between the productivity gains and the hype, something gets lost: us. This talk isn’t anti-AI, quite the opposite. It’s pro-human. We’ll explore the uncomfortable questions: What happens to the junior devs who never struggle through their first bug? If AI trains on AI output, where does that leave us? And when the code writes itself, what exactly are we here for?

And yet… What do we gain? Time. Space. The freedom to connect, to share, to think, to build things that matter. Remember those late-night debugging sessions with your developer friends, the magical, shared “aha!” moment when it finally clicked? That wasn’t about the code, or that fixed bug - that was about human brains buzzing together, and no artifical intelligence, however advanced, can replicate that.

Expect honesty, some existential questions, and zero “just add AI” solutions. If you’ve ever felt weird about how much your job has changed in the last two years — this one’s for you.

No OSS, No Users: Why Investing in Open Source Matters (🇺🇸)

At MongoDB, I help maintain the open-source tools that help PHP developers use our product. Without active, stable OSS, we shrimply wouldn’t have any users.

In this session, I’ll share why open source is essential to your product’s success, and how to get involved in the ecosystems that support it. Through real-world examples, you’ll learn strategies for contributing effectively, the value of community trust, and getting leadership buy-in to invest engineering time in OSS.

You’ll leave with practical ways to strengthen your product by strengthening its open-source foundations.

Observe FrankenPHP: DX Serving Performance (🇺🇸)

Every application has an engine: the runtime that executes your code. In PHP, it’s this invisible foundation working behind the scenes… Then one day, production goes down.

We shouldn’t, but it’s the ritual of panicked SSH. We run a futile « htop », try to guess which anonymous process is hogging the RAM, and drown in austere dashboards (sometimes ones we’ve never even opened…). Why is observability always perceived as a chore involving boring YAML files?

Let’s take the opposite approach: what if we transformed this black box into a simple, tremendous dashboard? Let’s put an end to tedious monitoring. We’ll dissect FrankenPHP’s behavior live and show you how to understand what’s happening by running one single command, with no configuration required. A surgical deep dive to track down memory leaks, manage your workers, and fine-tune your auto-scaling in real time. No prior knowledge needed. Live demos, stress tests, and open-source runtime insights await!

Own your content (🇺🇸)

In this keynote we are having a critical look at how the web went wrong. How we went from using common and open protocols to create a rich digital culture, to an environment were everything seems to turn into walled gardens and platforms, controlled by “big tech”, and algorithms, that can, at a whim, scupper your business.

We will look at how this control by big tech is detrimental to the open web, and open discussions, and having thriving communities.

But it doesn’t have to be like that. And in this keynote I will also show that there is a different path forward. One where we can tinker and thrive.

The ActivityPub protocol builds on top of the already existing infrastructure, providing the ways and means to build a decentralised way of interaction. Not only between people themselves, but also between different types of content, to build out the Fediverse. Like in the beginning, when the Web was for everyone.

Passer d’un monolithe à une galaxie d’applications : Réussir sa transition avec API Platform (🇫🇷)

Face à une équipe en pleine expansion, nous avons fait le choix de découper notre monolithe Symfony en plusieurs applications distinctes, gravitant autour d’une application centrale.

Notre allié ? API Platform.

Dans ce talk à deux voix, nous vous proposons un retour d’expérience sans filtre sur la mise en place de ce projet :

• Le Choix : Pourquoi API Platform est le compagnon idéal de Symfony pour structurer une architecture distribuée.
• Le Quotidien : Comment les State Providers et Processors sont devenus nos meilleurs amis pour manipuler nos données.
• Le Challenge : Nos astuces (et nos erreurs !) pour rendre nos composants génériques et maintenir une base de code propre à 15 développeurs.

Que vous lanciez votre premier projet ou que vous envisagiez une migration, venez découvrir comment nous avons dompté le framework pour répondre à nos enjeux de scalabilité.

PHP, Mercure et IoT – Quand PHP devient plus que Full Stack (🇫🇷)

Quand on parle IoT ou informatique embarquée, on pense à C/C++, Javascript, Python mais pas à PHP… Réparons cet affront en étudiant ensemble les possibilités que nous offre PHP dans le monde de l’embarqué !

Nous allons voir ensemble une application assez simple, nous permettant de déverrouiller des casiers à colis depuis une PWA, basée sur PHP, Symfony et Mercure… Pas parce que c’est utile, mais parce que c’est possible !

REX : Passer un CMS legacy en worker mode (🇫🇷)

Le worker mode, on en parle beaucoup mais peu ont osé franchir le pas sur des applications existantes. Et pour cause : c’est un changement de paradigme complet, bien loin d’un simple changement de runtime.

Points d’attention, pièges à éviter, benchmarks et nouvelles possibilités : ce talk vous propose le récit complet de l’étude entre mod_php et les modes workers de RoadRunner et FrankenPHP, sur le CMS d’un grand groupe média français.

Ce que vous pouvez en attendre en termes de performance, ce qui différencie réellement RoadRunner de FrankenPHP, et ce que ça ouvre comme possibilités ; le tout avec des chiffres et du vécu.

Running FrankenPHP Locally with DDEV (🇺🇸)

DDEV offers a powerful yet accessible approach to containerized development. In this session, we will walk through setting up a DDEV environment explicitly for FrankenPHP.

This talk explores adding FrankenPHP to a DDEV environment, covering both server configuration and the practicalities of daily development.

Learn how to leverage DDEV’s tooling to manage the full application lifecycle, from setting up the FrankenPHP runtime to handling routine debugging and data backups tasks.

Symfony on Laravel Cloud: What Could Go Wrong? (Spoiler: Not Much) (🇺🇸)

Laravel Cloud is initially built for Laravel. Symfony is not Laravel. So when our team decided to deploy our Symfony application on Laravel Cloud, eyebrows were raised, including our own. In this talk, we’ll walk through what happened next: the assumptions we challenged, the surprises we didn’t expect, and why the experience turned out to be far smoother than anyone predicted. You don’t need to know Laravel to follow along, just a basic familiarity with Symfony and a curiosity for what happens when you colour outside the lines.

We’ll cover how Laravel Cloud’s infrastructure maps naturally to a modern Symfony app, where the rough edges are (and how to file them down), and what this unconventional pairing can teach us about PHP deployment more broadly. Whether you’re looking for a managed cloud platform or just want to understand what makes a deployment platform tick, this talk will leave you with practical takeaways.

UX DataTables : réinventer les tableaux avec Symfony, API Platform et Mercure (🇫🇷)

Construire des tableaux de données complexes, filtrables et performants est souvent une tâche répétitive et chronophage.

Et si on arrêtait simplement de réimplémenter tout ça ?

Dans ce talk, je vous montrerai comment j’ai conçu UX DataTables, un bundle Symfony qui permet d’intégrer DataTables.net sans écrire une seule ligne de JavaScript. L’idée : tirer parti de l’écosystème Symfony et d’API Platform pour générer des tableaux puissants, cohérents et maintenables.

On verra notamment comment UX DataTables s’interface nativement avec API Platform pour exploiter la structure même des ressources.

Puis je montrerais comment avec Mercure on peut transformer un tableau classique en une interface temps réel, qui se met à jour automatiquement dès qu’une donnée change (plus besoin de refresh, tout devient réactif).

Enfin, je partagerai aussi mon workflow de développement avec l’IA : comment j’utilise des outils comme Claude Code pour accélérer la conception du bundle et itérer beaucoup plus vite sur des fonctionnalités complexes.

Why Silence Is Not Always Golden (🇺🇸)

Some developers cannot write a single line of code without music. Others are convinced that absolute silence is the only way to think.

This quiet disagreement shapes how we work more than we admit. It influences focus, collaboration, open office tensions, remote work rituals, and even how teams define “productivity.” Yet, most developers choose their work soundtrack out of habit, not intention.

Here’s the interesting part. Music is not neutral.

What you listen to while coding can directly affect your ability to focus, reason, debug, and create. Rhythm, tempo, and lyrics all interact with the brain in ways that can either support deep work or completely sabotage it.

In this talk, we will look at music the way engineers like to look at systems. What actually happens in the brain when you code with sound? Why do some genres help with flow while others destroy it? When silence works, when it does not, and how to choose intentionally rather than argue opinions.

We will explore research from neuroscience and cognitive science, test the silence-versus-soundtrack debate, and run a few live audio experiments.

Expect humor, relatable developer stories, and playlists you will want to steal.