Full stack engineers are the best because they control the whole process. This is my method I made for myself: the Awful Backwards Software Method ABSM 1.) write your SQL queries first with all the CRLUD; the L is for logical deletes and updates 2.) then setup your database to use these queries modifying the queries as need be 3.) then in your front end create the functions which implement your queries in the language of your choice - John Eischen © ADAGP Paris art humanitarian use is authorized except for any AI uses

I don't think this is already a pattern but maybe somebody else is already doing it like the above so please let me know if it is the case

I haven't worked in the frontend in quite a while, but when I interact with it, the problem seems to be that is written by a lot of inexperienced people, so it's full of rookie mistakes which make the tech debt even more unmanageable than the backend. Given that performance is more relevant to deliver a good ui in the frontend, unless you are going to but the devices yourself, the poor code ends up being a problem, so more people are hired to fix it, executing the vision of the more senior devs.

Given the situation with hiring, this might be good and still give some space to junior devs to exist. But I could be wrong and AI could be doing already a better job.

This is all very fair, and yet I think many would agree that the “frontend ceiling” is a thing, that many candidates are not skilled enough for the roles, and that the general state of frontend engineering is not great.

This is perhaps less true in 2025 than it was in 2012, but I feel it was largely the same until maybe 2022, and is still not far off this.

I think the engineering is underestimated, but also I think job applicants are very bimodal - some coming from a design or boot camp background, able to be productive but not run scaled engineering projects, and some from perhaps a backend/etc background and can scale a codebase, but who are prone to trivialising frontend development and giving less consideration to design and UX.

There is also the "backend of frontend", for a lack of a better term. When you've got a complex webapp, you start managing a lot of state on the frontend. You basically end up with a second database that you keep in sync, possibly two.

I think it's pretty common nowadays to have indexdb to cache data, but also your state management framework (ngrx,redux,mobx,etc) which sits between indexdb and your rendering framework.

I am (unfortunately) a FE engineer nowadays but I write very little HTML/CSS. It's mostly wrangling FE state and making it "efficient", cache invalidation, optimistic updates that mimic BE operations, etc.

I find that frontend takes most of the dev time for most apps, and I certainly consider it "harder" to get everything working to the quality level I want. However, backend work is usually more critical, as problems can result in data loss or security issues. Frontend problems often just result in bad UX, and they are easier to do a surface-level check too (just use the app and check that it works).

Due to this, companies may have a higher bar of expertise for backend which may give the impression that it is "harder", but I don't think this is a very important distinction.

I'm surprised nobody's talking about the hireability of FE vs BE engineers. The specialist vs generalist debate has been raging on for multiple decades now and the general conclusion is that only early stage startups hire generalists. Everybody else wants a specialist.

I'll go one farther: nobody hires senior FE engineers.

FE is perceived as having a lower skill ceiling than BE[0]. I rarely see an FE position (or a "senior" FE position) require more than 3 years of experience. And can you blame them when FE technologies churn so much faster than BE ones? It's still fairly common to have a decade old Java backend running against an equally old postgresql database. Who still runs jquery (other than levelsio)?

[0]: I do not agree with this, but it's a common perception.

It used to be front end needed to learn a new framework every couple of years but now with the balkanization of build tools as well it's even worse. OK for the first two or three decades, then gets harder. Is AI now making this easier - have AI do the nitty gritty framework specific code?

I do full stack stuff at my job but front end is my favorite thing to work on, particularly if it's an interesting UX.

I think a good understanding of design is also something people don't get about front end. Limited designs from designers means I fill in the gaps in some places.

Dealing with every possible edge case. Breaking out the advanced web APIs when they can easily solve certain problems, e.g. Intersection Observers or Mutation Observers.

Breaking out the advanced CSS APIs like @property rules for super easy and smooth animations.

Improving tooling and JS builds. Making sites fast and reliable.

On and on. Front end can get looked down upon if you're making the same old stuff over and over again. A modal here, a toast there.

But when you get assigned the crazy shit designers come up with, it becomes a very intricate challenge to create the the simplest solutions you can.

The demand is higher for FE Engineers precisely because it's easier. You have a low entry bar and more mediocre/inexperienced devs get in, create a mess and move on to better opportunities because now they have the 1 or 2 years extra of engineering xp and have also padded their resumes a bit.. also they need to higher more devs because tickets churn out rate is not the best either..

if you agree no need to up vote.. but if you disagree then do up vote as I told you something you needed to hear..

Because of endless design churn

Frontend isn’t easier.

Because front-end is the messier. Everything changes every 12-18 months.

My opinion on this matter is that in the Good Old Days, that is before LLMs, frontend development was just more laborious for average, run of the mill business web and mobile projects. There were several frontend developers needed for one backender, just because for business apps, backend is usually simple.

I would say in 2025, it has become exponentially more complex, not simpler:

1. The ecosystem has fragmented further. Every app uses even more tools and frameworks, each with its own quirks and version incompatibilities

2. With E2EE and blockchain-based apps becoming mainstream, the frontend now handles complex cryptographic operations, key management, and secure data handling entirely client-side. Mistakes here are security vulnerabilities

3. Advanced interactions, personalization, and real-time updates require sophisticated client-side computation. We're beyond "thin clients"

4. The Big 4 invest $millions in each interface and users expect the same level of UX/UI from anyone. Let's talk about simplicity on the surface :)