Taylor Otwell: What 14 Years of Laravel Taught Me About Maintainability

It was interesting to hear that Laravel, Drupal, Wordpress and Symfony communities do not mesh. I wonder why.

Laravel and Symfony is interesting, because Laravel sits on top of Symfony and releases of Laravel sometimes wait for releases of Symfony components.

The Laravel and Symfony communities are culturally very different. Laravel (and Taylor) are very US-American, Symfony (and Fabien) very European, and it comes through in communication style and presentation. Laravel has a share of users building products to sell to other Laravel users; Symfony doesn't. If I caricature, Laravel users are better at making money (as a Symfony user the social media presence looks like "grifting"); Symfony users at being architecture astronauts (and looking down on people "getting things done").

At a high level the WordPress community doesn't mesh because of having the WordPress way of doing things, and having a history of writing for old versions of PHP years after others have moved on and told users to upgrade. The WordPress community is fragmented into separate sub-communities which again don't mesh. There's the users who only build sites with page builders and hardly know how to code, those whose goal is to sell copies of their paid plugin (or hosting services), and those with permission to make changes to WordPress itself.

I've no recent experience of Drupal so can't comment on them.

As someone who came to Laravel from WordPress, I had a massive hole in my abilities to understand larger systems as a whole. During my tenure in WordPress, I actually got pretty good at the web native parts of modern web development but my “backend” skills were mostly about passing arrays around and doing simple database operations. Basic concepts like MVC were totally foreign to me and I was reminded of this a few months ago when I chatted with an old friend about their experiences with Laravel after the drama in WP land a few months back. When I told him that Models were not anything special and you didn’t need to scaffold out a Model using Laravel to create your own class against an existing table, his mind was blown and I could see the gears starting to turn. Mind you, this is a very successful solopreneur with a thriving theme business/platform and over a decade of experience; just that xp was in a domain set apart from the discipline of modern software engineering.

I’m super happy to have spent that time learning how to work with constraints to build absolutely giant systems (had a stint with an agency that worked for big online publishers that are known for using WP…) but after seeing the other side, I’m also happy to be past that and onto different and more interesting things.

The Wordpress community doesn't even mesh with the Wordpress community, let alone any other ones.

Laravel builds on Symfony so it is in some way natural that more real products/applications are released based on Laravel than on pure Symfony. Laravel has more functions built in and more practical packages for real use cases. Developing a similar app based on Symfony would require much more work.

I did PHP development for awhile, at 2 different places. One was a Laravel shop, the other was Symfony.

My biggest takeaway is Laravel is fast to get up and going with and ship something, while Symfony actually scales and is far more easily maintainable

If I were to choose building an app I expect to last I’d choose Symfony every time

Symfony and Laravel are fundamentally ideologically opposed.

Laravel is designed from the ground up to be used by junior developers who don't care about pesky things like maintainability and scalability and just want to put out the minimum viable product as fast as possible, and with the least amount of work possible. It's full of "magic" abstractions built with the primary purpose of making the code look pretty at a glance to the inexperienced, completely disregarding good programming practices and even essential language features in the process, the programming equivalent of lipstick on a pig. It markets itself to beginners as "the magic framework that does everything for you" and is as big as it is today purely due to successfully capturing a large percentage of that audience.

Symfony goes in the complete opposite direction: it's designed to be used by experienced developers to build maintainable, extensible applications while employing good programming practices. It encourages you to "look under the hood" and understand how things work instead of just telling you "to do X, write Y" without elaborating. It has many convenience features but they're generally built on top of language features with good practices in mind instead of handwaving it all away. It's very modular and allows you to extend and/or replace almost every part of the framework with your own custom version if the included version isn't suitable for your use case. And so on.

One of the best examples of Symfony vs Laravel is the way database tables are mapped to PHP code. In Symfony, SQL tables are just PHP classes. To create a new table, you create a new class, add the columns you want as properties, add some attributes to tell the ORM how to map all of that to a table, and it's done. Your database columns match your class properties, every time you query the database you get instances of that class and can use them as a proper objects with properly typed fields.

Laravel, meanwhile, does none of that, your database tables are defined purely by the database itself at runtime, what they call "Models" are just empty classes that have the database columns injected into them at runtime as dynamic properties. You cannot know what properties your Model has just by looking at it, I believe you need a Laravel-specific IDE plugin just to autocomplete them. You're essentially working with glorified associative arrays the whole time. This alone is a massive red flag that should make any experienced programmer avoid Laravel.

Wordpress sits on its own little island as a big pile of legacy code that's almost frozen in time, full of bad practices that no self-respecting developer wants to touch. No lipstick on this pig, it's as ugly as it is obtuse. It's still commonly used today because someone with zero programming knowledge can load up a bunch of plugins full of security holes and make a somewhat usable site that vaguely matches their vision, but using it for any new project more complex than a basic blog is generally seen as a mistake.

Can't speak for Drupal as I have no experience with it.

IMO, Symfony pushed for [better] standards and using a dependency manager are a couple of things.

Drupal took their time but finally started using composer and a lot of their components were Symfony components.

Wordpress just held their ground.

Technically, you could swap Eloquent for Doctrine which would solve the database issues but Laravel was built around using Eloquent and vice-versa, there’s very little documentation for using doctrine with laravel or using eloquent with symfony, it’d be easier to just use what grew up together.

Laravel is more akin to rails with its rapid application development but rails does it better.

Laravel is more like Rails in that sense, if you’re building a regular app, Laravel is very very fast to get something finished

Wordpress is old school. The PHP of Laravel and Symfony is light years ahead of the stuff in Wordpress.

Maybe they need to stay close to the metal based on the performance they need?

Not sure why Laravel decided to have that approach to models. In Django I can update the model properties and just generate a migration from that. I can always open the models.py file to see which fields a model class has. In Laravel I need to either look at the migration files or look inside the database table definition. And then also adding fields means writing the migration by hand I guess. There are other confusing things, like marking fields as fillable in the model, and if you fail to add your field in the fillable property, it won't be inserted into the database, and it took me awhile to figure out why my code wasn't working. Not sure what purpose it serves, I understand marking things as read only in serializers, but this is at the data layer, seems like a footgun.

Laravel uses the active record pattern, same as Rails. If anything, the Laravel implementation is the more pragmatic of the two.

It's fine if you don't like that pattern (I have my own misgivings), but it's a perfectly viable approach used by a lot of very experienced developers to build very successful applications.

Dismissing everyone who uses a framework or design pattern you dislike as "junior developers who don't care about pesky things like maintainability and scalability" is inaccurate, rude, and ignorant.

> it's a perfectly viable approach used by a lot of very experienced developers to build very successful applications.

"Lots of people use it" doesn't make it good. Lots of people in the past have written "successful" web applications as loose PHP files with little structure, no classes, using associative arrays everywhere (including me when I was starting out), but today it's generally agreed upon that this is not a good idea and will result in more bugs, maintenance headaches and an all around inferior developer experience, so what makes "active record" different?

I'd understand your point if it had at least some advantages over the ORM approach to make up for the clear disadvantages, but I just don't really see any beyond "it seems easier and requires writing less code" (which, as I said, primarily appeals to beginner developers who just want to get things done as fast as possible and don't understand the long-term consequences). Are there any hidden advantages I'm not aware of?

> "Lots of people use it" doesn't make it good.

I didn't say it was good (or bad), I said it's a perfectly viable approach.

> Lots of people in the past have written "successful" web applications as loose PHP files with little structure, no classes, using associative arrays everywhere (including me when I was starting out), but today it's generally agreed upon that this is not a good idea.

You're right, which is why, in 2025, no experienced developer builds web applications in this way.

Plenty of experienced developers build web applications using the active record pattern.

>Are there any hidden advantages I'm not aware of?

You mean aside from others having a different opinion about the relative pros and cons of active record, or personal preference?

> Plenty of experienced developers build web applications using the active record pattern.

Yes, but why? Why was the "loose PHP files with no framework" pattern abandoned, but not active record, when in many ways it's a remnant of the same era with many of the same drawbacks?

> You mean aside from others having a different opinion about the relative pros and cons of active record

I'm asking what the pros are.

> Why was the "loose PHP files with no framework" pattern abandoned, but not active record..?

Presumably because people still find active record to be a productive, sane, and scalable way to build web applications, unlike a disorganised collection of files.

> I'm asking what the pros are.

Speed, terseness, simplicity, and personal preference spring to mind.

You're talking as though there is some empirical "best way", but the fact is that every language, framework, tool, and design pattern has pros and cons, and those pros and cons will change depending on the project, and the individual.

Your list of pros and cons may differ to mine, simply because of personal perspective and preference, and that's fine.

Being blunt, I would expect an experienced, senior engineer to understand this.