Laravel 11

2024 didn't just feel like another year in the Laravel ecosystem; it felt like a tectonic shift in how we approach web development. As the year winds down, reflecting on the sheer volume of shipping that occurred reveals a framework—and a community—that is no longer just content with being the best PHP option. Instead, it is actively competing for the title of the best overall web development experience on the planet. From the refinement of the core skeleton in Laravel 11 to the explosive growth of Filament and the birth of Inertia 2.0, the pieces of the puzzle are clicking into place with a satisfying snap. This isn't just about code; it's about the developer experience, the culture, and the tools that make us feel like true artisans. Let's look at the biggest milestones that defined this year and what they mean for the future of our craft. Rethinking the Skeleton: The Radical Simplicity of Laravel 11 When Laravel 11 dropped in early 2024, it brought with it a moment of collective breath-holding. The team decided to perform major surgery on the project's directory structure, aiming for a streamlined, "no-fluff" skeleton. For years, newcomers were greeted by a mountain of folders and files that, while powerful, often sat untouched in 95% of applications. Nuno Maduro and the core team recognized that this friction was a tax on the developer's mind. By moving middleware and exception handling configuration into the `bootstrap/app.php` file and making the `app/` directory significantly leaner, they redefined what it means to start a new project. This shift wasn't just about aesthetics. It was a functional bet on the idea that configuration should be centralized and that boilerplate belongs hidden unless you explicitly need to modify it. While some veterans were initially skeptical of the "gutted" feel, the consensus has shifted toward appreciation. The new structure forces you to be more intentional. When you need a scheduler or a custom middleware, you use a command to bring it to life, rather than stumbling over a file that's been there since day one. This "opt-in" complexity is a masterclass in software design, proving that Laravel can evolve without losing its soul or breaking the backward compatibility that businesses rely on. Inertia 2.0 and the JavaScript Marriage The release of Inertia 2.0 represents a maturation of the "modern monolith" approach. For a long time, the Laravel community felt split between the Livewire camp and the SPA camp. Inertia.js bridged that gap, but version 2.0 took it to a level where the lines between the backend and frontend are almost invisible. The introduction of deferred props and prefetching on hover changes the performance game for complex dashboards like Laravel Cloud. Nuno Maduro and the team dog-fooded these features while building the Cloud platform, realizing that a UI needs to feel "snappy" and immediate. When you hover over a link in an Inertia 2.0 app, the data for that next page can be fetched before you even click. This isn't just a parlor trick; it’s a fundamental improvement in perceived latency. Moreover, the ability to handle multiple asynchronous requests and cancel redundant ones puts Inertia on par with the most sophisticated JavaScript meta-frameworks, all while keeping the developer safely ensconced in their familiar Laravel routes and controllers. The Testing Renaissance: Pest 3 and Mutation Testing Testing has historically been the "vegetables" of the programming world—something we know we should do but often avoid. Pest 3 changed that narrative in 2024. Nuno Maduro pushed the boundaries of what a testing framework can do, moving beyond simple assertions into the realm of architectural testing and mutation testing. Mutation testing is particularly revolutionary for the average developer. It doesn't just tell you if your tests pass; it tells you if your tests are actually *good*. By intentionally introducing bugs (mutations) into your code and seeing if your tests catch them, Pest 3 exposes the false sense of security that high code coverage often provides. This level of rigor was previously reserved for academics or high-stakes systems, but Nuno made it accessible with a single flag. Coupled with architectural presets that ensure your controllers stay thin and your models stay where they belong, Pest has transformed testing from a chore into a competitive advantage. Filament and the Death of the Boring Admin Panel If 2024 belonged to any community-led project, it was Filament. The "rise of Filament" isn't just about a tool; it's about the democratization of high-end UI design. Developers who lack the time or inclination to master Tailwind CSS can now build admin panels and SaaS dashboards that look like they were designed by a Tier-1 agency. The core strength of Filament lies in its "Panel Builder" philosophy. It isn't just a CRUD generator; it’s a collection of highly typed, composable components that handle everything from complex form logic to real-time notifications via Livewire. Josh Cirre and others have noted how Filament has fundamentally changed the economics of building a SaaS. What used to take weeks of frontend labor now takes hours. The community surrounding Filament has exploded, with hundreds of plugins and a contributors' list that rivals major open-source projects. It proves that the Laravel ecosystem is a fertile ground where a well-designed tool can gain massive traction almost overnight, provided it respects the "Artisan" ethos of clean code and excellent documentation. Observability and the Nightwatch Horizon As we look toward 2025, the buzz surrounding Nightwatch is impossible to ignore. Building on the foundation of Laravel Pulse, Nightwatch aims to bring professional-grade observability to the masses. The team, including Jess Archer and Tim MacDonald, is tackling the massive data ingestion challenges associated with monitoring high-traffic applications. By leveraging ClickHouse, the Nightwatch team is creating a system that can track specific user behaviors—like who is hitting the API the hardest or which specific queries are slowing down a single user's experience. This level of granularity changes the developer's mindset from "I hope the server is okay" to "I know exactly why this specific user is experiencing lag." It's the final piece of the professional devops puzzle for Laravel shops, moving observability from a third-party luxury to a first-party standard. Breaking the Barrier: The First-Party VS Code Extension For a long time, the Laravel experience was slightly fragmented depending on your editor. PHPStorm with the Laravel Idea plugin was the undisputed king, but it came at a cost. In 2024, the release of the official Laravel VS Code Extension changed the math for thousands of developers. Created by Joe Dixon, this extension brings intelligent route completion, blade view creation, and sophisticated static analysis to the world's most popular free editor. This move was about lowering the barrier to entry. If you're a JavaScript developer curious about PHP, you shouldn't have to learn a new IDE just to be productive. The massive adoption—over 10,000 installs in the first few hours—underscores the demand for high-quality, free tooling. It's a move that ensures Laravel remains the most welcoming ecosystem for the next generation of coders. Conclusion: The Road to 2025 As we look back on Laracon US in Dallas and the impending arrival of PHP 8.4, it's clear that Laravel is in its prime. We are no longer just a framework; we are a complete platform that handles everything from the first line of code to the final deployment on Laravel Cloud. The momentum is undeniable. Whether you're excited about property hooks in PHP 8.4 or the new starter kits coming in Laravel 12, there has never been a better time to be a web developer. The tools are sharper, the community is bigger, and the future is bright. Stay curious, keep shipping, and we'll see you in the new year.

Overview Fetching the same data multiple times within a single request is a common performance bottleneck. Whether you are retrieving a user profile for the header, a sidebar, and a footer, or fetching a list of featured items, redundant database queries waste resources. The `once` helper in Laravel provides an elegant solution for in-memory memoization. It ensures that a given callback is executed exactly once during the lifecycle of a request, returning the cached result for all subsequent calls. Prerequisites To follow this tutorial, you should have a baseline understanding of PHP and the Laravel framework. Familiarity with anonymous functions (closures) and static methods will help you grasp the implementation details. You will need Laravel 11 or higher to use this as a built-in feature. Key Libraries & Tools * **Laravel Framework**: The primary PHP framework providing the helper. * **Spatie once**: The original package that inspired this native implementation. * **Tinkerwell**: An excellent code runner for testing Laravel snippets in real-time. Code Walkthrough Suppose we have a `Podcast` model with a static method that fetches featured shows via an action class. Without optimization, every call triggers a new query. ```python // Before: Every call hits the database public static function featured() { return (new GetFeaturedPodcastsAction)->execute(); } ``` To optimize this, wrap the logic in the `once` helper. The helper accepts a `callable` and stores the result based on the calling context. ```python // After: Optimized with the once helper public static function featured() { return once(fn () => (new GetFeaturedPodcastsAction)->execute()); } ``` When the application executes this code three times in one request, Laravel runs the inner logic on the first attempt, caches the return value, and serves that cached value for calls two and three. This eliminates redundant database overhead instantly. Syntax Notes The `once` helper uses the object instance or class and the method name to create a unique cache key. It relies on a closure (`fn () => ...`) to encapsulate the logic you want to memoize. This pattern is much cleaner than manually checking if a property is null before assigning a value. Tips & Gotchas Remember that `once` only persists for the duration of the current HTTP request. If you need to store data across multiple requests or for hours at a time, you must use Laravel's standard `Cache` facade. Additionally, be mindful of state; if the underlying data changes mid-request, `once` will still return the original result until the request ends.

Refined Enum Queries in Eloquent Laravel has long supported PHP enums for casting, but a significant friction point remained when querying databases. Previously, while you could cast a model attribute to an enum, passing that same enum directly into a `where` clause often led to unexpected failures. The framework now handles this natively. You can pass a backed enum case directly into Eloquent query methods, and it correctly resolves the underlying value. This eliminates the need for manual `->value` calls, making your repository and service layers significantly cleaner. Automatic Password Re-hashing Security standards change, and Laravel 11 now makes it easier to keep up without forcing a mass password reset. The framework has updated its default BCrypt work factor from 10 rounds to 12, matching PHP 8.4 standards. The real magic happens during authentication: if a user logs in and the framework detects their stored hash uses an outdated work factor, it automatically re-hashes the password using the new configuration. This ensures your user data stays secure against modern brute-force hardware without any manual migration scripts. Capturing Metadata with Context Modern applications involve complex request lifecycles—controllers, jobs, and listeners often need access to the same metadata. The new Context facade provides a centralized way to store information that persists across the entire request. By adding a simple middleware, you can inject data like request IDs, current URLs, or authenticated user IDs into the global context. This data is automatically appended to log messages, providing an incredible audit trail for debugging without cluttering your code with repetitive log context arrays. Beyond Logging: Hidden Context The Context feature isn't just for logs. Developers can store hidden data that doesn't appear in logs but remains accessible throughout the execution thread. This is perfect for passing tenant IDs in multi-tenant apps or tracking internal execution flags. By centralizing this metadata, you reduce the need for passing variables through deep call stacks, keeping your method signatures focused on their primary logic.