Insights from JetBrains PHPverse Conference Part 2 — Building Better Software with Modern PHP

In Part 1 of our JetBrains PHPverse recap, we looked at how PHP is being re-engineered from the ground up, runtimes, packaging, and architecture. But that’s only half the story. What really stood out at PHPverse wasn’t just the systems-level changes. It was how much of the event focused on developer experience.

From Kévin Dunglas’ work on API Platform, to Ryan Weaver’s push for HTML-first UIs with Symfony UX, to Brent Roose’s no-nonsense dev tooling talk, PHP in 2025 isn’t just about keeping up. It’s about making things feel good to build again.

This is Part 2 of our PHPverse summary, and it’s all about how the ecosystem is improving the day-to-day work of shipping software. No overhauls. No yak-shaving. Just frameworks, patterns, and tools that help teams move faster without burning out.

PHPverse 2025 showcased more than features; it outlined a better dev experience. This summary connects the tools and practices that help teams move faster, stay lean, and build with less friction.

API Platform is Full-Stack Power with Symfony DNA

Kévin Dunglas’ session at PHPVerse delivered a clear message that API Platform isn’t just a time-saver, it’s a design tool for teams that care about structure, velocity, and maintainability. The talk focused less on what the tool can do and more on how it reshapes backend development when used end-to-end. It was one of the few sessions that showed what “modern PHP” looks like in actual product code and not in theory.

At its core, API Platform leverages Symfony components to formalize common patterns such as resource modeling, I/O, validation, messaging, serialization, and access control. The result is a system where application structure emerges from conventions, not custom scaffolding. Dunglas didn’t position this as an abstraction layer. He showed it as a pragmatic framework that helps teams ship production-ready features without accumulating hidden debt.

Why the API Platform Has Grown Beyond Its Name

API Platform started life solving the straightforward problem of API generation. What Dunglas revealed at PHPVerse is how far it has matured. Today, it’s a backend-first, full-stack engine that integrates GraphQL, asynchronous I/O, and frontend scaffolding, and all without abandoning Symfony’s core philosophy of explicit configuration and composable layers.

Critically, API Platform doesn’t discard Symfony, but it operationalizes it. That distinction matters. While many frameworks solve problems by hiding complexity, API Platform leans into Symfony’s predictability and structure, exposing just enough to keep teams in control. As Dunglas put it, this isn’t about inventing a new stack. It’s about orchestrating one that already works.

The inclusion of frontend support, whether via Turbo, Twig, or Symfony UX, means teams no longer need to default to decoupled architectures just to get interactivity. This resonates with the PHPVerse theme of infrastructure simplicityis that the less tech surface you need to manage, the faster you can ship and the fewer points of failure you create.

Developer Velocity Built In

What stood out during the PHPVerse session was how much real-world developer fatigue the API Platform absorbs. Automatic OpenAPI documentation and a zero-config admin panel remove the most common points of friction in backend tooling. Instead of stitching together auth, documentation, routing, and validation across packages, API Platform provides opinionated defaults grounded in production best practices.

The stack is CQRS-ready with native support for Symfony’s Messenger component. Event-driven designs, async workflows, and command/query separation are expected. Combined with DTO mapping, granular access control, and deep Serializer support, the stack is engineered for high-velocity iteration without sacrificing correctness.

Dunglas also highlighted how this architectural posture aligns with where the PHP ecosystem is headed, especially when paired with tools like FrankenPHP and the 103 status code support. Teams are no longer patching together dev tools. They’re building on unified, maintainable stacks where runtime, framework, and protocol-level performance all reinforce each other.

What This Means for Product Builders

The takeaway for engineering leads at PHPVerse is this - API Platform turns predictable patterns into reusable architecture. That’s not just time saved during sprint planning, but it’s compounded ROI over the life of a SaaS product.

So far at Accesto, we’ve mostly applied API Platform in CRUD-like situations. Since a lot of our business logic follows CQRS, we’re looking forward to combining API Platform with CQRS and rolling it out at a larger scale in future projects.

What Dunglas demonstrated at PHPVerse was an argument for consolidation which looks like less glue code, fewer unknowns, and a faster path to value. In an ecosystem investing deeply in runtimes, deployment, and AI tooling, API Platform completes the picture at the application layer.

Symfony UX is Reimagining Frontend for PHP Teams

At PHPVerse, Ryan Weaver made a clear case for Symfony UX, that frontend complexity has become a liability in many PHP projects, especially where the application logic is already server-driven. Symfony UX gives PHP teams a way to build dynamic, responsive interfaces while keeping everything inside the Symfony ecosystem. It reduces the need for duplicated logic, disconnected tooling, or isolated frontend stacks.

It was an interesting take, and Weaver didn’t talk theory. He showed a working system that handles modern UI needs using HTML as the foundation, with JavaScript used only to enhance behavior. The result is not a stripped-down experience but a deliberate rebalancing of responsibility between backend and frontend.

The Problem with Frontend Fatigue

Weaver opened his PHPverse talk with the observation that many teams are solving simple UI problems with overengineered stacks. Building pipelines, client-side routing, data synchronization, and duplicated form validation increase the maintenance burden without delivering clear product value.

At PHPVerse, this resonated with engineers who are building admin tools, dashboards, and internal interfaces. They don’t need a second application to manage, and they certainly don’t need to write everything twice. The fatigue comes not from JavaScript itself, but from maintaining a split architecture for problems that are fundamentally server-side.

Symfony UX is that HTML is the UI, JavaScript is the Enhancer

Symfony UX brings interactivity back into the PHP layer. Turbo handles partial page updates by replacing targeted DOM elements with server-rendered HTML. Turbo Streams and Frames enable real-time updates and dynamic interactions without a full reload. Stimulus adds modular JavaScript behavior at the component level, keeping scripts small, scoped, and maintainable.

Weaver demonstrated how Symfony’s Vite integration provides fast, modern asset builds with hot module reload and ES module support. Everything lives in the same codebase and deploys together. There’s no handoff between frontend and backend. Form logic, validation, access control, and UI rendering all operate within a single context.

The developer experience feels tight and deliberate. Changes are easy to reason about because the layers are aligned. Teams can build fast, test easily, and onboard new developers without having to explain a fragmented system.

Focused Interactivity Without Overhead

Symfony UX works best where reliability, clarity, and speed of delivery matter more than frontend abstraction. Weaver showed live-coded examples of modal flows, inline editing, and real-time updates, all handled with server-rendered HTML and targeted enhancements. There were no extra API clients, no redundant state management, and no need to replicate business logic on the client.

While at Accesto we’ve mostly leaned on separate SPA frontends in past projects, Symfony UX has matured to the point where we’re seriously considering it for upcoming builds. We may soon launch our first project with it, and we’re excited to see how it plays out in practice.

The closing point of this talk also hit close to home for many of us engineers, that most frontend complexity in PHP products is self-inflicted. Symfony UX gives teams a way to stop fighting their stack and start working with it.

Developer Tooling That Actually Respects the Developer

Brent Roose didn’t mince words at PHPVerse. His session cut through the noise of “DX” marketing to address a more grounded reality that developers are overloaded, and most tooling adds more steps than it removes. His argument wasn’t about preferences or IDE features. It was about energy. Modern toolchains should reduce friction across the lifecycle, such as startup scripts, environment setup, debugging, and deployment, because fatigue compounds over time and kills momentum.

Roose’s talk was a clear reminder that good developer experience is not about comfort, it’s about flow. A tool earns its place in the stack if it eliminates cognitive overhead without introducing hidden complexity. He walked through a set of tools that do exactly that.

Brent Roose on Developer Experience

Roose grounded his definition of developer experience in two outcomesis that fewer bugs and faster delivery. He focused on feedback loops, how quickly you can see the result of a change, how easily you can test an assumption, and how little context you need to start work. Anything that breaks that loop adds drag.

He emphasized three key principles for effective tooling. First, speed is that tools must feel instant. Second, discoverability is that features should be usable without reading documentation. Third, integration is that tools should sit close to where development actually happens, not in parallel systems that require translation.

If your local setup is brittle, your test suite is slow, or your deployment process is unpredictable, you’re losing hours every week. Roose framed this as an infrastructure problem disguised as a tooling choice.

High-Impact Tools Worth Your Time

Roose highlighted several tools that meet these standards.

• Symfony CLI does more than scaffold projects. It manages environments, runs local containers, integrates with Platform.sh, and standardizes service management across teams. For PHP developers working with multiple environments, this reduces config drift and deployment friction.
• Laravel Herd is a native PHP runtime manager for macOS. It lets developers run multiple PHP versions, switch contexts instantly, and skip the usual Homebrew and Valet setup.
• Expose allows developers to securely tunnel local APIs over the internet. It’s ideal for testing webhooks or sharing in-progress work without the overhead of deploying to staging.

Each of these tools earned its place by reducing setup time, removing blockers, and integrating cleanly into common workflows.

How Teams Can Use These Tools to Ship Faster

Roose’s session at PHPVerse made a simple point that most teams don’t lose time in code; they lose it between the lines of code. Broken environments, inconsistent setups, and staging bottlenecks are what slow down delivery.

Symfony CLI standardizes environments and service containers. At PHPVerse, Roose showed how it replaces scattered Docker scripts with consistent commands across dev, CI, and production. For teams working in parallel, this consistency reduces drift and speeds up deployment loops.

Laravel Herd eliminates setup friction on macOS. No more fiddling with PHP versions or FPM configs. PHP runs natively, switching versions takes seconds, and onboarding becomes a one-step process. Roose emphasized this as a quality-of-life upgrade that pays off every day.

Expose bridges the local/remote divide. At the conference, Roose demoed webhook debugging in real time with no deployment, no staging server, just an instant tunnel from localhost. This kind of tool shortens feedback loops during integration work, where speed usually suffers most.

At Accesto, these are the kinds of tools we use to remove friction at the team level. Not to chase DX trends, but to create reliable workflows that survive scale. PHPVerse validated that these aren’t niche utilities. They’re foundational to shipping faster and with less drag.

Modern PHP Is Also a Team Experience

At PHPVerse, the subtext across nearly every session was that the way a system behaves in production is inseparable from how developers interact with it day to day. Tooling is not a layer on top of the stack and it defines the shape of the stack itself. And when tools are designed with teams in mind, they become part of how knowledge is transferred, how decisions are made, and how systems grow without splintering.

What Makes a Great PHP Stack in 2025

What emerged clearly at PHPVerse is that effective PHP stacks are not defined by how many tools they include, but by how those tools converge. The highest-leverage environments are those where orchestration replaces fragmentation, where queue jobs, front-end rendering, API boundaries, and observability all live within the same architectural grammar.

Symfony and Laravel enable this kind of convergence. Their structure imposes a set of shared defaults around directory layout, environment handling, service configuration, and deployment expectations. These aren’t cosmetic details. They lower the cognitive load for new team members and reduce the time it takes to get a feature from prototype to review. In talks highlighting Herd and Expose, the point wasn’t performance, but it was consistency. Local development mirrors production closely, and defaults encode lessons learned, so teams don’t have to keep solving the same problems in different ways.

How These Tools Reinforce Developer Confidence

Several sessions emphasized that high-performing teams rely on predictability more than speed. Developers work faster when they don’t have to second-guess the state of a dependency tree or interpret custom conventions unique to a single project.

Composer 2.7’s caching improvements and secure install flows were framed as infrastructure upgrades, but their downstream impact is on team efficiency. Symfony’s LTS cadence is not just for stability; it gives teams a planning surface. Packagist’s redundancy upgrades are about availability, but also about removing single points of failure in workflows. These layers of reliability compound. They create environments where engineers can make changes without waiting for manual validation or defensive second opinions.

When we started Accesto as a digital agency 15 years ago, PHP’s biggest strength was how quickly you could get going, no extra tooling required, and it ran almost everywhere. Over time, the ecosystem grew more complex with frameworks and advanced tools, which brought power but also friction. That’s why it’s encouraging to see developer experience prioritized today, bringing PHP closer to those early days of simplicity, but with modern capabilities baked in.

Why Product-Minded Teams Should Pay Attention

The talks at PHPVerse connected technical decisions to product outcomes more directly than expected. Faster cold starts matter when new features are being deployed daily. Developer confidence matters when fixes need to ship without escalating review loops. Frameworks and tools that communicate clearly enable teams to move quickly without decoupling from long-term maintainability.

Accesto helps teams build systems that can change without unravelling. What PHPVerse highlighted is that this is increasingly a tooling problem and not a discipline problem. The right choices compound. The wrong ones stall everything.

Too many teams are still stuck in old PHP setups. They admire what other languages offer, while overlooking that PHP already has the same tooling, mature, production-ready, and waiting to be used. Modernizing isn’t just about upgrading tech; it’s about shifting the mindset. PHP is no longer just a website engine, it’s a full platform, and teams need to treat it that way.

The Joy of Shipping, Rediscovered

The second half of PHPVerse shifted the conversation. After digging deep into runtimes, protocols, and system infrastructure, the spotlight moved to the people behind the code, and the tools that shape how they work. The talks revealed a shared direction where developer experience is being designed into the PHP ecosystem at the framework level.

From API Platform’s scaffolding capabilities to Symfony UX’s HTML-first model, the emphasis was on reducing overhead and clearing paths. These tools do not just save time, but they also help teams avoid unnecessary complexity altogether. There’s a clear recognition that velocity comes not from abstraction, but from tools that understand how real teams work under pressure.

This is where modern PHP shines. For product teams building SaaS platforms, dashboards, or complex internal tools, the tooling discussed at PHPVerse solves the problems that accumulate over time, such as messy environments, long onboarding, slow feedback loops, and frontend/backend disconnects. These aren’t solved with new syntax. They’re solved with coherent systems.

Accesto helps engineering teams move in this direction and toward clean architecture, maintainable velocity, and development workflows that actually scale. The platforms we build don’t just work. They stay fast, readable, and resilient even as the demands on the team grow.

See how we modernize PHP stacks.