Why people say backend is lot easier than frontend?
Posted by Last-Box-9669@reddit | learnprogramming | View on Reddit | 417 comments
Heyy I am just curious that why people say frontend development is hard and backend development is easy compared to frontend. Is it true cause i am a 2nd years bachelor's student and only know react and tailwind mostly the frontend part and I find the backend complex to understand.
lulcasalves@reddit
They are different and suck in different ways.
wckly69@reddit
Because you dont have to center divs in backend development.
lanerdofchristian@reddit
It's really not that hard anymore.
danielhincapie_com@reddit
si implementas ese código no funciona
disposepriority@reddit
In general, if you take the most basic of projects (likely the projects the people you talk to work on) the FE is harder than the BE. This applies specifically to applications where the back end is just a thin layer between the user and the database.
This gets flipped around the moment you're working on a large scale system, with tens ( very often hundreds) of services, each with multiple instances, communicating through different methods (rpc, ampq, rest .etc) at the same time.
Jobs running in the background, distributed databases, third party integrations triggering logic on demand. The ceiling for back end complexity is much higher, so it very largely depends on what you work on.
MountainByte_Ch@reddit
100% its so funny to read frontend is harder than backend. it just rly shows who never worked on large complex systems.
danielhincapie_com@reddit
O que nunca ha trabajado en un frontend algo diferente a bootstrap o librerías prediseñadas
redcakebluedonut@reddit
I work in the quant industry and my service handles several dozen high traffic data feeds from several dozen parties all over the world who each uses different protocols and definitions, and that's just establishing working connections with each of them. There's still actually parsing/enriching/normalizing/validating the data while using/sending on several different internal services who each use their own protocols while accomodating very specific business logic for dozens of very specific cases. And doing this all while keeping in mind latency requirements and the shitton of tech debt over the last decade or so.
But sure, backend jobs are just crud webapps that read forms.
Enough-Luck1846@reddit
kubectl apply *.yaml
and everything works all of the sudden.
whossname@reddit
That's not going to solve the race conditions.
Enough-Luck1846@reddit
Microservice is by design solving race conditions. Only monolith can reintroduce it and very bad design choices.
whossname@reddit
You can still get race conditions with microservices. Mishandled cache for example, or concurrent edits of the same data. Microservices don't solve this at all, carefully designed code solves it.
Enough-Luck1846@reddit
If you approach it properly with a strategy you use in OS you can easily avoid but you need to know how buses and threading works in Unix.
In my opinion Backend is way harder. But when it is implemented it is as simple as Frontend. You just import or load up the middleware/module and never bother how it is implemented.
disposepriority@reddit
As a commenter below pointed out, this does nothing for the design of the services themselves. They lock databases, participate in multi-phase commits, sometimes they have to elect leaders for processes that shouldn't be done by the whole cluster.
Sometimes a service which was previously running on a single powerful machine hits a big bottleneck and has to be horizontally scaled, something it was never designed to do which can often end up as a huge mess to fix.
Tomorrow, your sales team agrees to sign a contract with a new shiny big client that their data will be completely independent of anyone else's, in a big multi-tenant application. As usual, engineers complaining that this is going to be a massive shit show are partially ignored or placated with "it's going to be a gradual rollout".
New regulations in a tenant's operating country can lead to hundreds, if not thousands, of manhours of work in the backend, while the front end related regulations are usually a pop up or disclaimer.
I'm not bashing on front end colleagues at all, just that the scaling on this side of the fence is often very ridiculous and spans multiple areas of expertise.
That being said, it's good to point out that these behemoth backend systems are not as common in every sector, so quite often the back end will be 4 services minding their own business and fetching stuff from a database.
Enough-Luck1846@reddit
It is whole IT department work not just back-end work.
kUr4m4@reddit
I completely agree, with a minor caveat.
Both backend and frontend can be extremely complicated. The backend for the many reasons you have enumerated, but the frontend, specially when you start to deal with low level graphics and/or complex mathematics can be just as difficult (albeit in a very different way).
turtleship_2006@reddit
Also, front end requires good UI/UX, which is outside the scope of just programming. You have to look at stuff like common conventions, and how users expect to be able to use your apps
You have to do usability testing on top of "does it actually work" testing
Cobayo@reddit
There's usually a dedicated UI/UX employee, just like there is an infrastructure DevOps.
Fspz@reddit
I do both UI/UX and front-end, and IMO in a complex system it makes a lot of sense to at least know quite a bit of both to be good at either, ideally while also being an end user of the software you're building.
In the industry people tend to think in silo's too much which is a trap that can lead to poor outcomes.
turtleship_2006@reddit
True at large companies, but wouldn't that still fall under "front end"?
(I've not personally worked at a large company so I'm just guessing
Cobayo@reddit
Surely, but your argument was "also UX/UI" as adding to it in contrast to the comparison. By the same argument "also infra" applies to the backend in the same fashion.
drew8311@reddit
When you add tech debt and continuous requirements that were not initially designed for both get equally complex regardless of scale
Science-Compliance@reddit
Hell, your backend could have over a trillion parameters! ;-)
BigLoveForNoodles@reddit
100% this.
This is especially true for student/instructional projects, where you can basically make the FE as complex as you want by adding bells and whistles. The kinds of things that make the back end more complex generally only start cropping up either when your problem domain gets more complex, or when you utilization starts to go way up.
Everybody hard until their etcd goes split-brained.
Oleoay@reddit
Most companies can get by with a decent backend and a decent front end. If you have huge amounts of data, BE gets very complex and precise while it can manage with a suboptimal front end.
blrigo99@reddit
I'm not sure who says that.
I personally find the backend to be harder to debug and with more things to keep in mind (database, API calls, jobs etc.).
FalseRegister@reddit
lol, same for frontend. You have API calls, multiple resolutions, multiple browsers, multiple languages, etc...). Plus the whole visual work to do. Frontend is more complex in many cases. Backend many times is mostly CRUD sessions, until you reach mid/large products.
moise_alexandru@reddit
Multiple browsers... that work mostly the same? Multiple languages... meaning JavaScript? I don't think many people use PHP. Or are you refering to HTML and CSS?
Frontend is quite simple to work on once you have the basics. In any serious application the backend is probably more complex than you imagine. Besides the CRUD you mentioned, you still need to implement security, logging, monitoring and alerts, testing, handle a lot of devops stuff - I won't even dive into that.
danielhincapie_com@reddit
no puedes hacer software complejo con frontend básico
Fit_Primary5052@reddit
Yes work mostly the same, until it breaks in the worst moment you can think of and clients will blame you and say sth like "It's a basic mistake that can be seen by eyes, not anything complicated".
Tbh, if you force a back-end developer to code a basic grid layouts, they will most likely screw up and get discouraged after a while
moise_alexandru@reddit
Something breaking on the frontend is much less of a problem than something breaking in the backend.
I'm very curious why you think backend devs can't code a basic grid layout. It's not rocket science, you can very easily find anything you need online. Backend on the other hand is very specific to the company and the application. The architecture and integration mechanisms are much more complex.
To me it's clear that anyone saying frontend is harder than backend didn't work on a real application. A local hosted CRUD is not a real application.
FearTheBlades1@reddit
That's way too general of a statement. It depends entirely on what breaks
redcakebluedonut@reddit
Frontend has its own complexities.
But the people in here defending frontend are so far removed from reality I'm confident not one of them has worked on anything other than crud webapps.
It's likely saying that painting a car is easier than building it, and then doubling down by saying building is easy 90% of the time because most cars are hotwheels toy cars.
Fit_Primary5052@reddit
It’s true that when something breaks on the back end, it can be very serious. But for back-end, it’s usually easy to track down issues via logs, because everything gets recorded there.
On the other hand, when the front end breaks, customers are usually not tech-savvy. All they can really do is send us a screenshot of the error, or at best give us a rough description. That makes it much harder to reproduce, since there aren’t any logs or clear traces of what actions the customer took.
What’s more, when something goes wrong on the front end, it’s immediately visible on the screen. Even if the back end is running perfectly fine, a front-end error will still block the customer’s workflow.
And trust me, I’ve asked plenty of back-end developers about this. Most of them don’t really know much about the front end at all. When you talk to them, they usually speak in “back-end developer language,” and it’s often up to the front-end devs to figure out what they actually mean.
PlanetMeatball0@reddit
Multiple resolutions also doesn't add complexity lol it adds time, where you have to spend the time setting the breakpoints and the sizing, but setting different sizes for elements isn't complex lol
Science-Compliance@reddit
It most definitely can be complex depending on the layout of your site. You may have multiple different layouts for one page depending on how your site is organized. This may involve not only CSS and HTML but different JavaScript, too.
PlanetMeatball0@reddit
Whoa a different layout?! How complex! Rearranging things, wow, the complexity
Science-Compliance@reddit
It absolutely can be. I can see you've never done anything particularly complex with your web pages. Try having a 3D animation that not only depends on the width and height of the page but also the total area and the position of different elements on the page.
PlanetMeatball0@reddit
Omg total area, you're telling me you have to do basic multiplication??? How complex!
FalseRegister@reddit
Yet another BE developer downplaying FE. Carry on mate.
PlanetMeatball0@reddit
Yet another FE trying to play up their work to be a lot more intense than it is. Carry on buddy.
Science-Compliance@reddit
You have to do more than that, and you missed the part where it depends on the location of other elements. You've never done anything particularly complex on the frontend. It's pretty obvious.
PlanetMeatball0@reddit
Okie dokie
yughiro_destroyer@reddit
Backend is easier because usually the logic is not that hard. All you do is write some endpoints that receive or insert/update data. That's basically what a CRUD is. Frontend on the other hand needs to be beautiful, responsive and work on the majority of devices.
CoderAsstronut@reddit
Things get complex once you evolve from just crud
gmdtrn@reddit
True! But that is rare. Most backend work is CRUD.
avocadorancher@reddit
Rare in tutorials maybe. Definitely not rare in real life.
gmdtrn@reddit
Most people literally build forms and simple CRUD to support those forms. Not sure why that is controversial. Most programming jobs are just not that hard. Maybe that's why? It's offensive to sensitive folks.
avocadorancher@reddit
Most people? Maybe juniors working with basic web applications. People are disagreeing because that is only a tiny slice of professional programming.
redcakebluedonut@reddit
The guy here is either completely non-technical, a first year university undergrad or a boot camp grad who thinks the world runs on typescript. No point talking to him.
gmdtrn@reddit
Oh, so you think most application development is for complex backend services and distributed systems? Please, enlighten me further.
The developers doing that work are often in specialized roles in teams at major companies that handle traffic at huge scale. That’s not what most developers do.
Be realistic, you know that the work the most developers do is going to fund the service that has a few hundred to a few thousand users. Don’t pretend like they’re doing anything complex.
From surveys we know half of devs work in companies with fewer than 100 ppl. Those people aren’t writing complex backend services.
We know that the toughest challenges that companies face is when they have to scale. So there is no doubt that at the extremes backend work is incredibly challenging. That’s why FAANG and adjacent have big, specialized, multi-disciplinary teams.
But again, that is not most people. That’s a small fraction.
The reality is if a person is making applications that will be deployed on the web, to a mobile device, or desktop it is mostly simple work for a small number of users. CRUD, auth, integrations, and simple business rules.
I’d love to have a better explanation from you about how you’ve concluded that most devs are doing complex work when only a minority of roles handle this kind of work. The math isn’t working here.
gmdtrn@reddit
Okay, that's fair. Let me rephrase. The context is the generic "back end". In that context a significant and perhaps the largest fraction is simple CRUD. Because a very large portion (again probably the largest fraction) of applications, web or native, are indeed simple CRUD with a few business rules sprinkled in.
The people solving technically complex problems on a daily basis are few and far between. I'm not claiming I am one either. I'd love to do so, but the opportunities are slim and I'm not willing to cut my pay by $250k at this point in my life to gamble on a startup. Thus, I content myself (and my team) with solving complex workflows with simple solutions. But I've interacted with enough people through hiring and graduate programs to realize almost everyone I've worked with does rote baloney almost all of the time.
CoderAsstronut@reddit
You will never grow with such a mindset
gmdtrn@reddit
What are you talking about? How does acknowledging what most backend work is (not actually hard) mean I won’t grow? I study constantly. I’ve got like 16 years of college behind me and multiple graduate programs.
MountainByte_Ch@reddit
depends on the company and the work you do. Yes as a junor you end up just doing crud backends. But once you become more senoir you start building your own tooling, reusable libraries etc and thats when backend becomes way more complex.
gmdtrn@reddit
The whole point of my being generic is precisely not to be specific. Of course there are exceptions and progressions. That doesn't change the fact that the lions share of the work that needs doing is indeed relatively straightforward CRUD +/- a few business rules. For me to be correct, only > 50% of the work would need to be of that nature. And, it's more like 70 to 80% of the total work that all engineers in that role do.
MountainByte_Ch@reddit
i think your numbers are way off. I'd be surprised if curd was more than 10% of working ours in my last 4 projects.
gmdtrn@reddit
Why do you have so much trouble understand that “you” are not “a population” from which we could estimate an average?
Arguing that your personal experience debunks my argument about averages just shows that your command of basic statistics is in need of revision.
MountainByte_Ch@reddit
and your made up numbers are just facts?
gmdtrn@reddit
Look at you, picking on a typo while having terrible punctuation. Smart person. I'm typing quickly, between work breaks, and after transitioning my keyboard layout to ColemakDH. What's your excuse?
If you're going to invoke the thread average as some authoritative source, let's up the meta and incorporate a set of Reddit, Quora, etc threads.
Google search engine prompt: "What percentage of back end software engineering is related to CRUD operations and supporting business logic?"
Response: "Determining an exact percentage of back-end software engineering related to CRUD operations and business logic is impossible, as the ratio varies dramatically by company, project, and experience level. However, experts generally suggest that these tasks constitute a very high percentage, with estimates ranging from 50% to as much as 80% or more for typical business applications."
And no, while my estimate wasn't founded in peer reviewed literature, it was based on a broader personal survey and in alignment with the fact that a giant fraction of app development these days is web, mobile, and simple enterprise apps that are largely offer collections of forms to their users to interact with, plus or minus a few bells and whistles.
Also keep in mind, time spent working is not the same thing as the percentage of tasks.
MountainByte_Ch@reddit
you actually belive this ai slop?
security, auth, pipelines, database migeations and all the other fancy stuff you've obv never done is the real work(and so fun to do)
i'd recommend you try doing some backend work you might like it. dotnet is rly beginner friendly
gmdtrn@reddit
I did enjoy DotNet. I’ve not played with it in a while, but do enjoy it. I prefer Go more though. So that’s my preference backend language for most tasks. I like the succinct syntax and their go routines. But I’ve developed backend services in C, C++, and more than use all many forms of IPC, PThreads, etc.
I’ve done a fairly wide array of development from systems to ML/DL, with my MS work in DL. Specifically focusing research on health AI. Lately most of my professional work has been in leading a team that develops applications that extend the functionality of a major electronic medical record system. And, that’s largely all Node; it frankly bores me a bit but such is life.
Anyway, I am very familiar with limitations of LLMs. I’ve made transformer based generative models from scratch. And I use them extensively. So I k ow their weaknesses, also their strengths. I am confident the LLM summary of a set of threads from top search results is going to do better than either of us extrapolating only from this single thread.
I’d recommend playing outside of DotNet a bit. Your right. It is really beginner friendly. And you end up with a narrow view of the outside world.
Impressive_Star959@reddit
Literally everything is CRUD in some form or the other.
gmdtrn@reddit
"Everything is just bytes!" No fucking joke. But you know what I am saying. There is a big diff between persisting/retrieving form data for a simple form (what many/most do) and writing services that use IPC, or in distributed systems, etc. We don't call distributed systems work CRUD even though there are analogous concepts all over the place because there is a lot more to it. Why you mad?
Impressive_Star959@reddit
I mean, you're the one who said most backend work is CRUD.
gmdtrn@reddit
And it is. That's not derogatory. "Most" is not all, and CRUD (in it's most generic context) is an essential behavior of nearly all modern apps. It's just not complicated. Most programming work is not complicated. The most complicated work you'll find in back end services, no doubt. But most backend work is simple persistence and retrieval.
Impressive_Star959@reddit
Well if it's just a Todo application, sure. Anything on a higher level is a lot more complicated and why systems design is a topic in the first place.
gmdtrn@reddit
You keep deflecting the obvious point. Most work people are doing is precisely of that nature. And, most tasks people are given by principles and leads will be of that nature. Most SWE's close tickets, they don't design systems. Precisely because most issues become complicated at scale, and very few companies solve problems or handle services at scale.
And, I never once argued that complicated systems are simple CRUD. I've stated the opposite multiple times all over this thread.
Vulven@reddit
Personally I found it more intuitive than frontend because when I started programming (and I assume others as well) the initial mindset that I had was manipulating data and nothing else which is closer to backend than frontend. Obviously eventually you realize that they are just a completely different skillset and complex backends do exist and are nowhere near "easy" but that was how I approached and perceived it back when I started out.
yughiro_destroyer@reddit
Yes but it's easy to keep things modular if I may say so myself.
I work in web development and everyone makes things more complex than they should be.
redcakebluedonut@reddit
All I needed from you
yughiro_destroyer@reddit
Ok mister smartass.
JimBoonie69@reddit
Brother you know there are more complex systems that CRUD backends lol. Holy shit dude just go change the color of this card real quick and resize this box please. front end requires no thought brother.
Lil bro thinks backend means crud api endpoints =p
Glittering-Work2190@reddit
Compare the front-end to www.google.com and the backend that does the searching. Which is easier?
SandwichDmiga@reddit
I wouldn't say it's easier, BE actually requires more algorithmic thinking than FE.
But I find BE simpler to understand because you feel more in control, and therefore know (or not) what's going on, in FE the technology tend to be such a mess of layers that it's just about learning the bag of tricks for that framework in question.
blrigo99@reddit
For a very simple system maybe this is the case.
For complex applications the backend needs to juggle multiple APIs, Jobs and different database dependencies on top of any functionality based feature your application has.
RoboticShiba@reddit
Other way around for me. Many backend languages have pretty useful debugging tools and have better error tracking on production environments. When a production error happens on the backend, I have the full stack trace including non-object values passed between each function of the stack. Meanwhile, the stack trace for a react application in production is a nightmare, even if you're uploading the map files.
rafark@reddit
In production, but in dev is so good. I’ve been using the webstorm debugger after using console.log all my life and it’s a MUCH better dx. I still prefer backend though, but having a proper debugger makes the dev experience much more enjoyable. I hated having the dev tools open all the time.
R4M1N0@reddit
Yes, I do like to debug Greenfield or Isolated projects in the, but external systems can make backend a god damn hell too because nothing is documented and everything must be imitated.
Worked on a project where data synchronisations need to go 2 API Gateway layers deep (due to access control compliance reasons) just to talk to some REST API that will (hopefully correctly) read and write data to some 2 decade old main frame database tables (that are shared between quite a bite more applications of the same age), some other voodoo magic will happen on that table so that you have to eat the data back to your local state (and god forbid there is a bug that will corrupt any data).
I know this is more a rant against missing documentation of decade old systems, and sure, frontend and UI programming can also be total ass, but sometimes you at least know what you are up against.
But yea, a full backend landscape you mostly control can be a breeze to manage.
Fspz@reddit
Depends on what you're building, there's some wildly complicated front-end stuff out there too.
danielhincapie_com@reddit
El backend es mucho más estable, más solido, hay una o muy pocas maneras de hacer las cosas y lo que aprendes te puede durar años. En frontend la velocidad de los cambios es más alta y lo que sabes ahora no es lo que servia hace 4 u 8 años..
La lógica del frontend además es muy visual y depende mucho de una gran diversidad de dispositivos diferentes, los backend acostumbrados a una sola salida no se sienten cómodos.
Y no son habilidades tan distintas, solo que deben ser abordados con distintos contextos
Lase189@reddit
Frontend is harder because it's user facing. I find backend easier but I find all sorts of development easy compared to EE which I majored in.
brogamer99@reddit
Well as a backend dev, i feel it is the opposite. In the startup i am working on, i have to design the tables, create procedures, create backend, create a way to reflect those changes in client, prepare api docs and give it to frontend team. They will call the api. That's it. If something doesn't work, guess what, its on me.
Diligent_Luck_1079@reddit
Backend for a company with fewer users is 10-100 times easier than making a huge system. That is not the case with frontend. Frontend can be as challenging for a small and a big-sized system. Have you seen Amazon's frontend? :).
So if you are working on a system with very less users backend can be easier. In general, of course not -.-
Embarrassed_Quit_450@reddit
Frontend tooling is garbage so there's that.
AshleyJSheridan@reddit
They're both different.
On the frontend you need to worry about the different types of browsers (which are mostly aligned these days, compared to when IE was still around) and the different new features you're able to use.
On the backend, you're more in control of your platform, but you have to worry about architecture, performance for traffic peaks and general load, authentication, database management, and date migrations.
Move a backend developer onto a front end project, and worst you get is a website that doesn't look quite right.
Put a frontend dev onto a backend project, and worst case is your server becomes compromised and your entire company becomes legally liable for data loss.
But yeah, sure, backend is easier. /s
zica-do-reddit@reddit
It's apples and oranges really, there is no comparison. Well, more like apples and watermelons.
Acceptable-Tear-8899@reddit
It is pretty predictable how much time a new feature on the backend will take. However, usually it is NOT predictable how much time a new feature on the frontend will take, some small button fix can sometimes take 5 hours instead of 5 minuted to make it look just right.
Ah, and another thing is that LLMs are terrible at design. If you have a designer in your team, this is not so much of a problem, but if you are on a solo project or in a very small start-up, then with frontend there comes the design part too, which can be tricky.
AusEngineeringGuy@reddit
The backend is where all the domain complexity lives. Front end is not hard. I’ve been full-stack my whole career.
Let’s be honest front-end devs get spoon fed Figma designs and say go make it pixel perfect.
Historical_Copy_9004@reddit
TL;DR: Full-stack dev here - backend isn't easier, it just hides complexity in business logic rather than UI states.
Hey! Java Spring guy here who works across the stack (Python, React, Tailwind). Neither is "easier" - they're just different beasts.
Backend feels simpler at first because you don't wrestle with CSS or browser quirks. But the real complexity is in the business logic - your code becomes a vehicle for complex workflows that serve users. That's where backend gets tricky.
Frontend is hard because users see everything - every pixel, every lag, every edge case. Backend hides behind APIs.
My advice? Just start building! Pick whatever excites you right now. Find solid open-source projects on GitHub to learn from - reading good code teaches you more than tutorials. I learned Spring by studying real projects, not docs.
You already know React/Tailwind - that's awesome! Try building a simple API for your React app. Once you connect the pieces, both sides will click 🚀
Aceventuri@reddit
Backend is data in, do some stuff, data out.
Frontend is similar to backend datawise (you have to do stuff with your backend data after all) PLUS the ui.
There is potentially unlimited and subjective work in designing a ui. Data is either correct or incorrect so easier to work with than a subjective ui. In a Ui there is maybe no right answer?
I think it's different if you were being tasked with simply the coding steps and someone else had already designed everything for you. In that case they would be closer in difficulty.
For me anything in front end takes at least 3x long as backend because I can't make my mind up on how I want the ui.
saxbophone@reddit
Assuming you're talking about web —So much more control. Typically, on the backend you have a lot more scope to lock down the specs of what you're running on, and you also normally benefit from working within a paradigm where flow control is a lot easier (typically speaking). On the frontend, so many specs are subject to variation, portability and compatibility are major concerns. From subtle rendering differences between browsers to JavaScript APIs that aren't available on some browsers and requiring polyfills to work... also, code running on the frontend is event-driven and there is nothing you can do about this. Code on the backend at least has an entrypoint, and is a "program" in the more traditional, synchronous sense (some frameworks you might use may diminish this if they are event-driven).
dmlane@reddit
This may or may not be relevant: Sir Isaac Newton stated “I Can Calculate the Motions of the Planets, but I Cannot Calculate the Madness of Men”
OkTry9715@reddit
Because front-end is mostly done in Javascript or any other version of it.
movemovemove2@reddit
They are completely different, but saying backend is easy can only come from people who never did complex backends.
Beautiful_Grass_2377@reddit
I find backend easier not because I think is technically easier, but, for ME it easier to work on problems that are ot subjetives.
Frontend is way too much subjetive, you have to deal with people feelings ad it's not something I enjoy
movemovemove2@reddit
Peoples feelings my ass. That‘s for ux and design, I start with their deliverables so why bother where they come from.
Informationflow is the primary discriminator in my book. And informationsflow insofern neat in a backend and pretty much chaotic in frontend.
gmdtrn@reddit
This is also true. Backend for complex services with large user bases is incredibly hard. That said, most devs will not do that. Most devs will work on small to medium sized code bases where their backend work is CRUD, auth, and API integration. In that case, it’s like front end without the HTML/CSS and framework sprawl.
various911@reddit
Not easy, but not more difficult than frontend. I’m from C++, then Java/C# then obj-c/swift/js/php/flutter. I can say most complicated thing is combo of html/js/css. Writing them is not difficult but master is extremely effort. Backend more than computer science, frontend more real life, you must be fast, realistic, pragmatic
movemovemove2@reddit
I‘m with you. I like to switch between so can tackle different sets of problems.
The thing with the browser languages is mostly that people never take the time to learn them properly and most just don’t get the separation of concerns between them.
Most devs who never did inversion of control don‘t get css and a lot of devs don‘t get what ‚semantic‘ mean and do not get html. In js land everyone thinks he can do it because there are curly braces.
BarrySlisk@reddit
Complex backends are rarely required (in web development).
movemovemove2@reddit
One or a few webbased frontends are in front of any backend system, no matter the complexity. In bigger systems, there might be a bunch of apps and some native backoffice applications as well.
There is no webdevelopment backend.
Prestigiousdeli@reddit
A genius admires simplicity.
movemovemove2@reddit
A genius creates simplicity in a complex environment.
EarhackerWasBanned@reddit
He's quoting Terry Davis.
“An idiot admires complexity, a genius admires simplicity.”
qwkeke@reddit
Yeah, we got that. But just because he's quoted something popular in an argument doesn't suddenly make his point valid. Because everyone should write nothing besides hello world programs with that logic.
EarhackerWasBanned@reddit
So... you admire complexity?
qwkeke@reddit
I admire common sense when interpreting quotes. You admire quotes to be worded like legal documents to make it idiotproof. The irony of having that happen when talking about that particular quoue is quite hilarious.
EarhackerWasBanned@reddit
I just know where the quote comes from. You're assuming I agree with it.
But whether I do or I don't, arguing against "an idiot admires complexity" by stating how much you admire complexity is a bold move.
qwkeke@reddit
As I already said, the quote talks about the compelity of the solution, while idiots interpret it as talking about the complexity of the problem.
RighteousSelfBurner@reddit
It's also very evident in real life. One of my most challenging solutions were three lines of code that was for all intents and purposes a hack but solved the problem and saved the company a ton of money. Took me a month to write. Yet when you look at it without context it looks really stupid.
Seltzerpls@reddit
Why are u yapping so hard ab this lol
movemovemove2@reddit
Still think the sentence need polishing. A stone is simple, why would anyone admire it?
It‘s man made simplicity in a complex solution space that is admirable 🤪
OrthogonalPotato@reddit
Because a stone wasn’t created as a solution to a problem? What a stupid comment. Sorry, but really, that was not even close to relevant.
KronenR@reddit
Wild how you went full professor mode to ‘correct’ someone while literally repeating the same point they made. All that condescension just to end up agreeing with them — impressive way to prove the quote backwards
OrthogonalPotato@reddit
The stone example was awful, and nothing you say will change that.
KronenR@reddit
Cool, so now we’re just discarding reasoning and facts in favor of tantrums. The stone’s awful because you said it is — genius move, very persuasive
qwkeke@reddit
Terry Davis was clearly referring to the complexity of the solution, not the complexity of the problem you are required to solve. Also, the simplicity of the solution will be compared in relation to the solution of the same problem.
You can't compare the solution of outputting hello world in C to the solution of creating and maintaining a top tier OS kernel like the linux kernel, then claim that the guy who wrote the hello world program is a genius compared to all the linux contributors because his solution was much simpler. Complex problems will naturally have more complex solutions than simpler problems.
The guy you're grilling was talking about complex backend problems. His only mistake was giving a bad analogy about the stone rather than something more suitable like the hello world vs linux kernel example.
OrthogonalPotato@reddit
Yeah, no shit. That’s why I brought up the NAND gate. I literally am talking about the solution. Can you read?
qwkeke@reddit
Seems like you're the one who can't read.
movemovemove2@reddit
Yo but the quote was simplicity, not simple solutions. You misread this.
OrthogonalPotato@reddit
I didn’t misread it at all, and I am not talking about the quote. I am talking about the reality of simple vs complex solutions. Think for yourself sometime.
movemovemove2@reddit
Dude I was literally only talking about the quote. So you misread big time.
No one argues that a simple solution to a given problem is better than a complex solution to the same problem.
Then come non-functional requirements and everything ends up in spaghetti 🍝😘
NoOrdinaryBees@reddit
I hope you see the irony in your using 179 words to excoriate this person for (IYO) not appreciating elegance.
OrthogonalPotato@reddit
Says someone who doesn’t understand what irony means, and also doesn’t understand that concepts take a lot of words to explain. What a trash take.
Plus-Violinist346@reddit
The backend can be so complex.
In what appears to the lay person to be a simple crud app, it's possible to have a pretty basic brick and mortar back end, especially if it's built in like Go or something plain and straightforward, but just a modern reactive stateful front end a la react , typescript , bundlers, various this and that, html / css, various devices various displays, etc has more BS going on.
kbielefe@reddit
There are objectively harder and easier parts to both, but most people personally gel better with one or the other. Backend might be repetitive CRUD or highly complex and performance sensitive. Some people really enjoy the highly visual nature of frontend, but there's also a lot of cognitive load with all the frameworks, etc.
shit-takes@reddit
But in reality, you are not going to be writing complex backends all the time in a job.
C0ckL0bster@reddit
But in reality you're not going to be writing complex front ends all the time.
EarhackerWasBanned@reddit
Frontends don't have "standard" behaviour. There's no frontend CRUD for example. Or MVC. Or microservices (microfrontends is a joke played on us by shite managers who can't organise teams).
There's no frontend that could be built in a day with an install script and a few unit tests. There's no "configuration as code" for frontends.
I've worked on beastly backends, but only a handful. I've built a ton of simple backend services though.
I'd say that a complex backend is a lot more complex than a complex frontend. But in the React/Angular/Vue world we live in, every frontend is a complex piece of engineering.
TomWithTime@reddit
I moved to backend because the front end complexity in projects like ngrx and redux was killing me. There was so much code that didn't serve the business objective. But with backends, if you exclude cloud and infra (if your business has a dedicated person to manage them), a much higher percentage of the code you are writing is doing business work.
That was my limited experience, anyway. After experiencing gql and a few abstraction patterns that make the back end just as much of a pain in the ass to write 1:1000 lines of work:clutter, I no longer hold a strong opinion over either.
Svelte came to rescue front end projects from complexity. Maybe a dead simple pattern will come rescue backends in the future as well. Probably won't help established projects, but I'd consider a pay cut to reduce the amount of pointless code I write.
rust_trust_@reddit
Engineering is not easy, any engineering, no frameworks can save you, it can abstract a lot of cases but then you are not an engineer just a software plumber who plumbs things. But then you will forever be in the rut of working for someone and doing the same changes and patterns till you retire.
TomWithTime@reddit
I like the business more than I dislike the tech, but if it continues to evolve on its current trajectory, I may be facing some hard decisions in a few years.
Which I wouldn't mind if it wasn't something mind numbing like adding or removing or renaming a variable means updating a dozen files, protobufs, gql schema across every project in your distributed monolith, etc.
But part of that pain is from embracing these enterprise patterns while we have FOUR FUCKING DEVELOPERS, so it's possible in the future with a bigger team to manage each micro service that it won't be as painful. We will announce a field change and then a dozen teams will run some scripts and submit boilerplate PRs. Maybe AI will get precise enough to handle that without mistakes. Whatever the future is, I just hope it's not me doing that forever.
shit-takes@reddit
You definitely are. There's so much client involvement and design changes, because all they see is the visual aspect.
qquiver@reddit
This really depends on the use case.
ThunderChaser@reddit
That quite literally is my job
TrickedOutKombi@reddit
Generally the orchestration of how backends operate and communicate can be quite complex, but if you're separating your concerns correctly it can be broken down into managable chunks rather easily
movemovemove2@reddit
Frontend as well. Good seperation of concern is key to all software structure.
jonas00345@reddit
I feel the other way. Sure a brilliant UI is tough but most are not brilliant. I find UI work is straightforward and its the backend where i spend time.
turtleship_2006@reddit
Making a functional UI can be relatively easy. Making a good UI isn't as much, and expands beyond just the technical side like programming (you also have to look at conventions etc)
With a backend, you get away with a lot more of "if it works it works", especially if it's not for external use, partially because the only people using it directly are other programmers who'll likely be able to figure it out more easily. A shit UI will lead to a stream of people asking how to use it
movemovemove2@reddit
It‘s a matter of preference. I like to do both to keep my mind connect bottom up and top down thinking.
Infinite-Bathroom694@reddit
My opinion having experience with both: backend may be difficult and complex, but is predictable. In other words, once you package and deploy it just works. Exceptions and new issues happen, but your code is doing what the code says. Frontend is unpredictable. Shit works on Chrome N, but won’t in Chrome N-10. You have multiple browsers, extensions, analytics and all sorts of shits thrown at you. An exception on the backend is what it says it is (unless your backend is garbage, but that’s on you).
ExtraFly4736@reddit
I would not say easier, i would say more stable in the way it changes less than frontend.
Front being the most user facing layer/tier it change more rather than the backend logic in general (changing design rarely impact much the rest api from the backend).
chf_gang@reddit
Frontend is theoretically easier, but in reality it's a lot of fidgeting and rewriting until everything looks and works the way it's supposed to - writing code to design a UI is just not very intuitive.
Backend is a lot more straightforward but requires a bit more CS knowledge on how APIs and databases and other stuff works.
Elegant_Pear6664@reddit
Simply not true, just difference in skill requirements
Shazvox@reddit
First time I've heard of it... though FE is the part that introduces what people see which is where *shudders* opinions and subjective values come into play...
martoxdlol@reddit
It is not that simple but, if you do things right writing backend (endpoints/procedures/functions/queries) can be very straightforward while the frontend depending of the case can get complicated.
Said that, you can also say the same thing the other way around. In the end it depends on what you are building and the architecture. A good backend can be complex and also not all backend are just basic http endpoints.
But I can say that I felt a few times that getting the UI, state management and everything right was much harder and a lot more work than just writing a few endpoints and SQL queries.
Stradivarius796@reddit
Seriously tho, who said that? Lol. Front end is definitely hard on its own term, but back end is completely different monster
LichtbringerU@reddit
Just saying AI is becoming very good at basic front ends… (and most frontends that are sold and bought are basic/exactly what Ai is good at.)
BurnedRelevance@reddit
If the back end doesn't work, you'll know it. It can't really mess up without your knowledge, but CSS certainly can.
The front end will change with the size of the users screen, so any product you're styling needs 3 different layouts, and then the fun begins:
Once it's a product everyone can see, it changes from Tech to Art, as you're trying to please a client.
People in general have a hard time describing what they want and you'll work for hrs for a look that they just don't like. It's not the coding that's harder, it's peoples expectations.
Freelance Web Developer
40YearOldWhiteDude@reddit
Different programmers have different aptitudes for type of programming problems. If the person isn't honest about themselves, they think what they find easy is easy for everyone.
spiderzork@reddit
Never heard anyone say that. They're completely different skills though.
dr_tardyhands@reddit
I've heard it. After spending like 6 months on front-end stuff (and hopefully never doing it again): that shit makes no sense to me.
Axman6@reddit
But what about the mythical all-stack developer?
gmdtrn@reddit
Useful for small to mid sized projects. Not for giant projects. And having knowledge of both ends is informative. But on big projects you’ll need to have people who specialize.
kernelangus420@reddit
Does full stack involve being a designer too?
qquiver@reddit
That's the title on paper but we all know that each of us are far better at one than the other
CodeAndChaos@reddit
That's very true, I'm fullstack but much better in the backend. What takes me 3 hours to do in the UI, I'm pretty sure a pro frontend developer can do in 30 mins.
MrDontCare12@reddit
Let's create a "fullstack only" agency! I'm fullstack, but what takes me 3 hours to do in the backend... Etc
UntoldUnfolding@reddit
Mythical? Why would someone not be able to do both AND non-web development?
ChairDippedInGold@reddit
Perhaps they're referring to when working with a client? They wouldn't care about the backend as along as it functions but they have all the say in the front end.
Man_Bangknife@reddit
It's the people. It's always the people.
LoudAd1396@reddit
This. Backend either works or it doesn't. There are edge cases, but it still comes down to whether or not the input matches the output.
Front end is a matter of opinion, and it has to work across a million devices, and at every possible resolution.
Dyshox@reddit
That’s a weak argument. A backend can work for 200 clients and fail for 10mio.
gmdtrn@reddit
This is it. Backend becomes harder at scale. Small services etc are easy. But large services require teams and smart planning.
PolloCongelado@reddit
The backend runs on the server. How could it wouldn't work for 10 clients? Only way I can think of is if they want to run the backend on their physical servers. We'll set up the server machines then.
C_Hawk14@reddit
10 million, not just 10
Mori-Spumae@reddit
Version mismatches, timeouts due to latency, network segregation issues, certificate management, ... ?
notevolve@reddit
I may be wrong, but I think they were pointing more toward subjective, cross-device behavior rather than just pure scalability. Stuff like responsiveness, layout quirks, or general UX across tons of different devices. Sure, you run into issues with scalability on the backend, but that's more about performance and reliability under load, not the subjective variability of how things look and feel to different users.
Fembussy42069@reddit
This is not true all the time, specially if you are working on a product where the backend is more than a crud api. A lot of the time the backend suffers from lack of specificity imo, for example, product always forgets to explain what to do with permissions, or access rules, or very specific edge cases you end up having to handle (which roles should allow what resources? What if x and y are true? All of this ends up mattering)
Hawxe@reddit
No the fuck it does not lol
LoudAd1396@reddit
The matter of opinion is "what is good enough"?
I've had enough clients who want line breaks just there no matter the viewport size, but the font still has to be x size.
Some demand 1000% pixel perfect. Some understand that the design has to be fluid across devices.
Yetiani@reddit
definitely, people under estimate how much of a pain in the ass is working with people as clients, teaching, nursing etc
KronenR@reddit
True, but backend also deals with clients… they’re just called frontend developers. And trust me, they complain just as much.
Yetiani@reddit
hahahahahahaha omg I'm dying
Simple-Economics8102@reddit
A UX designer is literally a game changer in this regard.
Mythasaurus@reddit
Yep. This. Every idiot has an opinion about UI. 😂
Bowmolo@reddit
That's actually the problem of backend work. While in frontend, everyone seems to have an opinion - which is the problem there - regarding backend, people are ignorant, which is a problem of at least equal scale.
Ubuntu-Lover@reddit
So they don't care about security?
Yetiani@reddit
definitely people under estimate how much of a pain in the ass is working with people as clients, teaching, nursing etc
CodStandard4842@reddit
Well Clients complain about backend performance on their atari server infrastructure all the time
Hebrewhammer8d8@reddit
What a reverse from 13 years ago AMD was floundering, and now Intel is sucking and AMD dominates in desktop and eating server space.
afedosu@reddit
My ex-boss was saying the same thing. I work solely on the backend but i did some minor programming for FE in the past. I hate FE and i think it is more complicated. Especially, web and mobile.
not_some_username@reddit
I’m one of those that said that. It’s because I’m crap at designing job
Zealousideal-Bad5867@reddit
Most of backend framework make backend développement easier, less configuration, easy to connect with other techno (Kafka, elasticsearch...) In frontend, it's the opposition, several years ago, frontend dev was easy, and the more frameworks are released , more the dev is complexe. A lot of configuration, need 400 lib to create an application...
FatefulDonkey@reddit
If anything, it's the opposite. But the backend is just less code generally
First_Result_1166@reddit
Backend: Works or doesn't work. Easy to write unit and e2e tests. Might have scalability issues.
Frontend: Customer states icon is misaligned by 1px when using Internet Explorer on Windows 95.
dr-christoph@reddit
it comes down to what you are doing. simple crud backend? easy. complicated microservice architecture with message oriented middleware, eventual consistency, delivery semantics, resilience, graphql api gateway, authorization and all that stuff? hard. simple react frontend? easy. complex ssr react, redux state management, tanstack query/rtkq, custom components, custom visualizations on top of native canvas/webgl, webassembly, graphql clients, grpc clients, authorization and all that stuff? hard.
grappleshot@reddit
The places I've worked at recently have had Product Owners to deal with clients and design teams to build the UI, so a frontend dev doesn't have "people problems" some have mentioned here. Assuming frontend means something like React, it's a mess because its evolving so quick and there's no real accepted standard. I've seen that in the main front end built at my current company. Some Mobx, some Redux, some React components, some other thigns. It's a hot mess. (unit) test coverage is down. Tailwind went in a while ago, but there's still every other way of managing styling from the last 7 years.
By comparison backend (C#) is more structured, more test coverage, more patterns, better coding standards, less libraries. We have a reference implementation for new API's (we do microservices) and that dictates what libraries can be used, and for the msot part, the archecture of teh code.
IMO (Full stack lead, but am backend leaning), backend is otherwise harder. I define backend as "everything not frontend", so that inclides API's, cache layers, databases, infrastructure (queues, buses, other PaaS things on Azure and AWS). A frontend dev "just" calls rest endpoint and the backend teams make the magic happen for all the "ilities".
Brocolli123@reddit
Idk about easier but more comprehensible and less subjective. Html/css just doesn't make sense to me
Wnb_Gynocologist69@reddit
Probably due to the tech stack. Many backends don't use tech stacks of transpilers with a language that has no runtime equivalent and causes lots of version dependency lock ins depending on the framework of your choice and libraries you need.
Relevant_Custard5624@reddit
Probably someone who doesn’t understand backend. I’m in an internship (our team is building an app), and one of the frontend guys thought backend was just setting up a Postgres database, and didn’t know we even wrote code, so I had to explain what we actually do. Now he understands a bit about backend and how the two connect. I don’t think either is more or less difficult than then the other, if you’re doing things correctly, and building more than just a simple webpage with a couple basic routes, they both can be challenging.
BarrySlisk@reddit
Responsive design is pretty hard if you are new to it. And it used to be that every browser had it's own way of doing things (not so much anymore).
ForeignNight8782@reddit
Its completely different set of skills. Imo, I think people who like the logical aspect of programming, like data structures, system design and are obsessed with optimising performance, love backend programming.
I too like it, and I hate frontend. But a developer and a SDE are two different people. A developer is a person who's specialized in some particular skill. Like you can say React Developer Nodejs Developer Swift Developer....bla bla bla
But a SDE, is someone who gets sh*t done. He's like a jack of all trades, but master of none. They're expected to program in any languages and come up with a good working stuff. They have to work in backend as well as frontend technologies.
So, as a SDE, most of my time during frontend projects, I found myself frustrating over why a particular logic in frontend is not rendering it correctly. Or you will get some wierd bug that won't just get resolved, until you throw timeouts, flush, whatever gets it working.
But in backend, you get detailed logs. You can trace back to the source of the error there. I think backend development has a more clear path, both in coding aspect and debugging. And that's why people like it
EatingSolidBricks@reddit
Nobody says that
Simple backends are simple
Simple frontends are simple
Complex backends are complex
Complex frontends are retarded
ckim777@reddit
Front End client based is really annoying having to deal with picky clients or people who ask for things that aren't feasible. Back End can be more complex, but you are practically invisible if everything is working right. Sometimes people might even think you are some magical genius in the backroom for keeping everything together.
Amazing_Prize_1988@reddit
Lol
poolhoose@reddit
I think backend development at scale is much much harder than frontend. The problem is that most companies don't really have large scale systems, so it's not until you go to a faang or large scale company that you see the difference.
I also find that most frontends are artificially complex due to overly complicated frameworks that are implemented without the need.
dude-dud-du@reddit
I work mainly in ML and don't have much of any frontend or backend experience and think both of them are hard 👍 It just depends on what you've learned and have experience with!
No-Situation423@reddit
its completely reverse and people who think frontend is harder than backend and just too stupid to even comprehend the backend
Professional_Gate677@reddit
I’m a decent developer, but I suck at styling. So for me front end is harder in regards to making things look nice. However in my world, corporate reporting systems, looks don’t matter that much as the data. If I was building a website for regular consumers I’d definitely be in a world of hurt.
snigherfardimungus@reddit
Because they're crap at cost effective engineering?
salamazmlekom@reddit
Because it is.
Alternative-Bobcat-5@reddit
Backend is Function, Frontend is design.
Front-end solo devs obtusely tackle low-end backend functionality calls but most back-enders couldn't be bothered with color psychology, copywriting and client satisfaction. Backenders can be stubborn, and still get paid for it. Frontenders could be stubborn but.. they'd probably end up clientless.
DamionDreggs@reddit
Laymen have way more opinions about the look and feel of a product than they do about the injection molding equipment it came from.
bbro81@reddit
As a backend engineer I think front end is way harder and I think that is a bias a lot of other people share.
Now UX is a totally different thing and I think that is the hardest of them all lol
Barajmar-@reddit
I've never heard this I'm my life it's always backwards haha backend mocking front end and both of them giving full stack shit
Physical_Duck_8842@reddit
I believe we should categorize people not by which brain hemisphere they use, but by whether they can code front end or back end. And there are outliers of course: full stacks that can do everyting and full stacks that sucl at both.
Back end is intuitive to me. Sure there is a lot of room for growth ahead of me but I understand it faster at least.
On the other hand I hate coding front end because I struggle a lot coding a GUI that does what I want.
Web - Mobile - Desktop is pretty different too. I write desktop applications much easier than web applications.
Ratatoski@reddit
In web dev you could get quite far as a frontend with a modest skill set through the 90s and 00s. These days frontend is full on programming while dealing with browser inconsistencies, users and an ever changing landscape of frameworks.
Attraction1111@reddit
Well, it depends.
I would argue that if the system solves somewhat a complex problem the backend and frontend would not be "easy" for either, but often the backend falls under harder.
Client side frontend's often gets away with multiple things that the backend would not. Such as scalability, availability, performance, hosting and networking.
Also using a BFF(backend for frontend) would house most of the domain logic, making the development on the frontend much easier, assuming the api is classified as rich.
Fyren-1131@reddit
I'm a backend dev, and I find it a lot easier to understand. I've spent many hours trying to get into frontend, but it's always so unintuitive. Javascript just doesn't make sense to me.
tangerinelion@reddit
This says more about Javascript than you.
Enough-Luck1846@reddit
It is too abstracted away with very bad design choices.
ITslouch@reddit
If you have a more mathematical and logic-driven mind, back-end makes more sense.
If you’re a ‘close enough’ person, front end with JS and CSS is for you.
Mayan_Apocalypse2012@reddit
Back end is easier to learn for people who are a programmer's programmer because front end supports people to completely make up how their company designs web pages, and that inherent lack of a need for web dev standards to have standards as long as the page is functioning wantedly & can be readable when inspected. Take something like the push for flexbox & grid to be standardized in CSS - you can still visit 10 different major app front ends and find 10 semantically different ways of naming the implementations of a sites layout, even if the ruling is all or roughly the same.
SafatK@reddit
There is no easy end! If you want to build something truly awesome, it will be hard work.
Contrary to what you said, most people find backend to be complex and I think that’s largely because the back end is not as intuitive to the human mind as the front end stuff tends to be. User facing interfaces make a lot more intuitive sense to our monkey brains. But doing a good job requires effort in either case.
Traditional-Cup-7166@reddit
It’s the opposite
FigureFar9699@reddit
A lot of it depends on perspective. Frontend feels harder for some because you’re constantly dealing with design, user experience, browser quirks, and making everything look/feel right. Backend can seem more straightforward since it’s mostly logic, APIs, and databases, but it also gets complex with scaling, security, and system design. Since you’re coming from frontend, backend might just feel unfamiliar right now. With practice, it’ll start making more sense
mistyharsh@reddit
There are two aspects of this.
A decade ago, the challenge with frontend was the runtime. Each browser had its issues and bugs which did not yield consistent result; Internet explorer being the most used and notorious of all. That situation did not exist for many backend tech stack. Fast forward now, most of the browser implementation are now based on either Webkit or Blink (With Firefox being an exception) and are following specification to a great extent. So, things have settled down on this front.
However, frontend community has invented its own demons in terms of introducing accidental complexity. I would quote Next.js as a famous example. It solves problems that do not need to exist for vast majority of the applications.
However, being a full stack developer, I can confidently say that saying backend is easier than frontend is a blanket misleading statement. If you are building Figma or real-time market trading platform, then both backend and frontend are equally complicated. If you are building Rich Text Editors, then Frontend is more challenging than backend which is only doing the CRUD operations. If you are building timezone related applications, you will have challenging backend. And, this is endless.
_BeeSnack_@reddit
I think it's just because it's so much easier to introduce bugs in the FE
The past 3 sprints... I've probably fixed 8 different bugs that were predates my tenure at the company...
BE is all logical flows. And the only real bad bug that we fixed recently was a class based component that pulls the current date in when the class is initialized, and not calculating dates JIT
CaptainFromDite@reddit
Depends on the scale of the project. If you're a beginner and making something from scratch, that's to be used only by a few people then the backend will be relatively simple and barebones. The UI however will need to be made according to Desktop and Mobile. A beginner will feel quite overwhelmed by the amount of responsive design thinking that needs to go into things as well as the overall design of UI.
When people start out with learning programming, there is a very shallow focus on UI. It is only meant for display, not meant to be interactive. That's why people struggle with making interactive UIs and as a result say such things.
However, when you go to an application designed for masses and meant to scale, backend becomes a completely different beast where you need DevOps, solid testing, multiple server deployment, cost management, security, robust caching and DBMS, etc.
In conclusion, Backend difficulty scales with number of users and has a curve starting from 0
Frontend starts at an arbitrarily higher point but the curve is much more gentle.
That's why people at the origin point think Frontend is more difficult compared to Backend
MartyDisco@reddit
Its the complete opposite actually. There is a reason why frontend jobs are the first endangered by AI.
SuchBarnacle8549@reddit
For most products or businesses that are not just for show, they have many business use cases. Business use cases are usually tied to the backend, and depending on how complex the requirements are, so how large the organisation is, or target users, complexity can vary.
A blog, showcase or sales page? Frontend is likely more complex design wise, backend can be a simple CMS. A complex business with many workflows, use cases and large teams? Microfrontends are not simple to tool up, and building features in a multi team microservices environment is not simple at all.
It all varies and anyone giving a blanket statement just shows how shallow their experience is. But overall most development for software products are tied closely to business requirements, and it depends on whether the business requirement is tied closely to the UI or the backend.
From personal experience, most businesses don't focus on complex UI tooling to deliver business value, so frontend requirements tend to be just building nice UIs etc rather than complicated UI designs or tooling.
Environmental_Pay_60@reddit
Because you (mostly) dont have to deal with HTML and css in backend. Least how i feel it.
HomelanderOfSeven@reddit
Frontenders did this to themselves by overcomplicating the whole stack out of nowhere. Now it's an unoptimised mess.
amdcoc@reddit
Cause backend works the same for both mobile/desktop.
MaverickGuardian@reddit
One thing might be that JavaScript ecosystem frontend frameworks and tooling is a mess. There are so many frameworks and versions of different libraries and tools that do exact same thing but differently.
This has been creeping into backend too as JavaScript is getting more common in backend side too.
Many times battle tested tools are better than new shiniest libraries.
No-Arugula8881@reddit
You don’t think there are “so many [non-js] frameworks and versions of different libraries and tools that’s do exact same thing but differently” on the backend? I feel it is the same if not worse, we are just spoiled by package managers.
the_mvp_engineer@reddit
Well Java doesn't really have this problem. Almost everyone just uses SpringBoot. Sometimes we need to decide what library to import StringUtils from. For testing we have a choice between Junit5 and...oh that's it. Then for logging we have to choose between slf4j or log4j2.
PolloCongelado@reddit
Yes. And în this day and age I find that simplicity beautiful in itself.
ethan4096@reddit
Depends on a language. Go didn't change much since its release.
MaverickGuardian@reddit
I guess it can be depending on the language and of course project, etc. I have always tried to keep things quite minimal. No framework, just http/grpc/etc. server library and db client, maybe some lightweight object mapper and client for cloud resources.
But yeah. If you use java spring or some other massive framework. Sure it will get complex.
I guess maybe backend mindset is bit different? As it needs to be secure, it also needs to be quite simple? Otherwise keeping packages up-to-date can become painful.
But this is just from experience and not based on any statistics or data.
I haven't seen any simple web UI project since vanilla js days and most of those were complex too. Maybe I should try creating something and see how things currently are.
wbrd@reddit
I've had so many fights with people on Node being anything more than the presentation layer.
RyZe15@reddit
As a backend developer I can say frontend is fkin hard. At least for me. Everytime I have too touch something in the front it's like 2 hours because something (you can't debug html and css) isn't working.
miguelangel011192@reddit
I always heard the opposite to be honest. But I can see how for a new starter learning just backend frameworks could look simpler and organise in the way things are now, and frontend more diverse and confusing. Being honest you can do one, or both, are more the things that make them similar than the one that make them different.
meester_@reddit
Im front end hired as back end trying to go full stack
Most back enders learned a few front end things back in the day, their front end knowledge is outdated, they never liked front end and they just want to live in their tangled up nested functions in the back end.
I dont get it either, front end is way easier lol
Miserable-Job-1238@reddit
Frontend is the bane of existance. I'd take coding in Java for hours than spending a single hour using CSS
echols021@reddit
I personally find backend easier than frontend because "if it works, it works". Frontend is too subjective for me. Not everyone will have this same view, though
Dont_Die88@reddit
I've got problems with my backend and frontend. Figuratively and literally. Anyone want to help me debug?
crybabe420@reddit
back end performs logic for the sake of logic. the requests (both literal and figurative) we make on the back end are discrete and precise and already formulated in logical terms.
front end performs logic for the sake of humans. the requests made upon the front end are just about anything a user could think to try or expect and anything a designer expects users to think. the front end is an interface between logic and human mush.
all the extra handling for the human layer needs to be considered and coded out.
watergoesdownhill@reddit
I don't think either are more difficult, but generally the back end does more work and has more things happening, which makes it more challenging architecturally.
At the simplest, the front end is interacting with the user and it's just handling with the UI layer, not even business logic. However, some front ends are very complicated and I think they'd be very challenging.
redditreader2020@reddit
They haven't worked long enough. Frontend is easiest and most annoying.
ShimReturns@reddit
For me I've worked on the same backend tech for almost 20 years (C# and SQL). Yes it's .NET bow instead of .NET Framework and EF instead of stored procs but it's not that different.
I did WebForms forever and now even after a few years of Angular I'm no where near as comfortable.
AndyLucia@reddit
As a very broad generalization: backend is more algorithmically complex, while frontend requires more up to date knowledge of different tools. BE is more “academic”, while FE is “messier”.
FlavioMoreir4@reddit
Ease, if it exists, is subjective, as complexity manifests itself in other ways, such as business logic, security, integrations, performance and scalability. In short, it's a matter of affinity with solving infrastructure and logic problems, not of difficulty
DigThatData@reddit
because they already know backend and don't feel like learning frontend.
OdMaL@reddit
I think backend is easier to start with, but there is no limit on how complex it can get
Watsons-Butler@reddit
“I need you to resize this
sunsetRz@reddit
I'm full stack web developer. Backend is the pain while I always have fun while coding the frontend.
On the frontend, You can have many components and inspiration from others while the backend is solely dependent on that Business strategy. You are on your own, and many things are involved too like apis, end points, cron jobs, heavy security, http methods, business logic, marketing, payments, overall database management etc...
chesnett@reddit
It's more of whatever makes the most sense to you. So, if it's hard, you haven't understood the fundamentals yet.
jaibhavaya@reddit
Yeah I’ve never heard this. It’s also a moot conversation. They’re both different paths that can be followed for long enough to reach equal levels of complexity.
Pale_Height_1251@reddit
People typically say the opposite, but it really depends what you're making.
UntoldUnfolding@reddit
What I don’t get is why people create this dichotomy in the first place. Are you a developer or not? You should learn how to program.
Learn the puter. Learn the worky so when no worky, you know why no worky.
Stock-Chemistry-351@reddit
Because with backend it's usually a set way of doing things. With frontend there's a shit ton of ways to do one thing and snot nosed bastards will always tell you their way is better than any other way trust me bro.
iheartrms@reddit
Frontend is where the people are. Yuck. A bunch of different incompatible browsers with different extensions, a marketing guy who tells you he wants the website to "pop"... Frontend sucks.
CommunityTough1@reddit
24 year web dev veteran here (PHP, SQL, and front-end). They aren't really directly comparable. Front-end has its challenges mainly with cross-browser compatibility once you get into advanced things, plus maintaining interactivity across display sizes and input devices.
Back-end has its challenges mostly with concern to security, big data management (complex relational systems and writing SQL statements with like 20 joins and a specific output formatting), and the fact that you probably need a little bit of DevOps (spinning up VPS server, docker container, etc, configuring them, and general server maintenance) skills to even get started.
Frequent_Bag9260@reddit
Front end is much harder simply because you get a lot of unqualified people commenting on it because they can see part of the output. Everyone has an opinion on the UI and constantly wants to change it.
Those same people can’t comment on backend because they 1) have no idea what’s going on and 2) don’t even see the output of the work.
Gatoyu@reddit
This. The key element is "if a human being interact with it it will be chaos" it can be a webpage, a game or a public API, humans = troubles
its_all_4_lulz@reddit
I think this is the answer. Backend can be more black and white. It works or it doesn’t, or it works well or it doesn’t.
On the front, it works, but Jen from HR thinks it’s too far left, while Bob thinks it’s too far right, and Tim thinks it’s just right. They’ll all voice their opinions about it, create meetings about it, and just stall progress over it.
The front end has a lot of grey area because it comes down to UX/IA on top of what’s being delivered from the back. UX and IA can be controversial. The placement of the button can be based on user research, AB testing / heat maps / interviewing, which is often biased anyway.
Frequent_Bag9260@reddit
Exactly. I think UI shouldn’t even be considered front end. It’s like saying that painting a car is the same thing as designing a car.
Archduk3_@reddit
Backend looks complex initially but with breakpoints and line by line debugging, it becomes much more easier.
mikiencolor@reddit
Because in backend development, we have to deal with frontend developers. In frontend, they have to deal with actual users. 😜
Orango_magno@reddit
Front end tends to have more bugs
meyriley04@reddit
If anything, it’s absolutely reversed
OneRobuk@reddit
I think overall backend is harder no? Frontend is easier to do with component libraries and tailwind
theycallmethelord@reddit
It’s less about one being “harder” than the other and more about the kind of mess you end up dealing with.
Backend feels complex at first because it’s abstract. Servers, databases, APIs. It’s all invisible so you can’t see if you’ve wired it up right until something breaks. Once you know the patterns though it’s pretty consistent. Auth works the same way across apps. Queries are queries.
Frontend isn’t always complicated in theory, but the surface area is huge. Every browser, every screen size, every accessibility rule, every team preference about design systems. You’re not just writing code, you’re negotiating with a hundred moving parts that don’t care about each other.
If backend feels complex now, it probably just means you haven’t seen enough of the recurring patterns yet. Once you do, a lot of it turns into repeatable building blocks. Frontend always keeps a layer of chaos on top.
txjohnnypops79@reddit
I do full stack, its more fun and I have control.
ikeif@reddit
Mostly it’s because of interpretation and context.
In a hypothetical scenario:
The backend is written in a language. It’s consistent. You have it dockerized. It’ll run the same wherever you deploy it. Generally speaking - you take an input, generate an output. And it should be consistent.
The frontend: it’s cobbled together across three frameworks and old jQuery code. Maybe a home baked framework. So - how well do you know the framework? How well do you know JavaScript/CSS/rendering/time to paint? Browser differences? Mobile vs desktop? How many desktop sizes? Integrated metrics and analytics? How many browser versions do we need to support?
A lot of those answers aren’t the developer’s call. It’ll be a business call, that can change at any time, possibly causing entire pivots to be done on the front end.
But the backend will stay the same.
Sometimes, the backend is cobbled across multiple programming languages, but they all focus as input/output with data, while the front end has a lot of considerations - an api call will work. But is it accessible? Is it rendering properly? Oh, we have a new frontend no code solution - migrate to that! It’ll be sooooo easy!
I work in both, and sometimes, yeah, the frontend is a bigger annoyance and “difficulty” than the backend code.
Clean-Gunts2860@reddit
Programming is programming, and a given task has a given complexity. But... the frontend technology landscape is terrible. It's run like a popularity contest, voted on by the masses, and noobs who build little content websites for game money have the majority vote.
Unknown_Warrior274@reddit
Probably since you are asking software devs, which likely got into CS because they like math. Front end requires graphic design knowledge, which is more often than not something a typical nerd lacks. There are people who exel at both but not everyone.
IVIichaelD@reddit
I think the reason why you’ll hear that in university is because intro classes usually start with console applications and it’s a smaller jump from that to a basic API than from that to a React app.
But it looks like you’ve ignited the age-old frontend vs backend debate in the comments, which personally I think is a bit antiquated. Nowadays it should be a conscious design decision depending on the problem where you want the complexity of the solution to be, and wherever you put it will probably be the harder area. There is no cut-and-dry answer.
Soft_Dev_92@reddit
Because front end is a shit show.
pat_trick@reddit
It's a different kind of complexity, but back end has one thing that you usually don't have to deal with: UI. Often back end is just passing data around, manipulating it, storing and retrieving it, and sending it somewhere else. With front end you have to deal with layout, presentation, accessibility, web browsers, CSS, and an additional layer beyond just your data.
SuchTarget2782@reddit
Backend almost never has a GUI component.
It’s not “easier” - it uses different skills. But at a lot of companies it does seem like PMs pester the UIUX folks more because of visibility reasons.
chrisfathead1@reddit
I think front end is harder lol
Crafty_Rush3636@reddit
Because they don’t like frontend. I say backend is easier, that’s because I abhor frontend and try to stay away from it
AnswerInHuman@reddit
“Easier” is generally relative to what you tend to be good at. It’s like asking weather it would be easier to learn Portuguese or German. If you’re an Anglo speaker German might be easier, if you’re Latin Portuguese… and if you’re Asian you might be equally lost. Or you could have an aptitude for language and symbols and just slay any language.
As a general dev, specially nowadays you’ll probably do both, and possibly much more (testing, devops, networking, cloud admin, maybe even business analysis). But you can always go deeper into subjects or synthesize them and make it harder. Sort of like how problem in math tests suddenly have 3 or 4 book problems in one. That’s how it’s applied in the real world
YetMoreSpaceDust@reddit
IME the problem with front-end is that you're expected to be a bit (or a lot) of an "artist" whereas with backend you're just supposed to keep a lot of trivial details straight.
rm-rf-npr@reddit
Both can be incredible hard and complicated, or simple and easy. People that actually participate in the "frontend vs. backend" debate dont know what they talk about.
Both are nice, both are necessary, both can be hard. If you say anything other, you don't know what you're talking about.
l00pee@reddit
I've been at this decades and the thing about frontend that you don't encounter with backend is that people see the front end. Backend is not subjective. It's cut and dry. Does it execute business logic without bugs? You're good. Code is complete and out the door.
Frontend is much more subjective. Everyone and their janitor has thoughts on frontend. Once the code is sorta complete, you will find yourself pushing pixels, changing colors, and when something doesn't match someone's subjective tastes, it's a bug. It can be grueling at times keeping the stakeholders happy. And about the time you get it right, things will need to be freshened. Meanwhile the backend is still chugging along and doesn't change.
Imagine the blue hair receptionist that has the ear of the CEO but doesn't like the color of the site. That's a change. And so forth and so on.
In short, ux is hard and not an exact science, so it can be incredibly tedious. The other side of it is that when it's good, it's more satisfying. But the problem is, frontend can be like an art project that never feels quite perfect. Backend you know when you're done.
AffectionatePlane598@reddit
I think that is just you being around front end people who like to complain
anotherrhombus@reddit
Lack of experience in engineering complex systems. Really that's all there is to it. I'd think just about any full stack software engineer that has 10 or so years of project experience under their belt will agree.
It's just very rare for the average person to ever run across a project that is actually pushing the boundaries of the browser design wise. Poorly executed SPAs that aren't even needed for the project? Almost always a self inflicted wound. But not inherently harder, just skill issues.
jameyiguess@reddit
I feel like there was a tiny age where that was true, but it's generally not anymore.
I'd argue that backend difficulty has more difficult extremes, but on average, frontend dev is a PIA way more than backend.
Cybasura@reddit
I mean, frontend is difficult, but partly because you have to design and css is pretty damn confusing (works though, of course)
Backend is also difficult if you're from frontend, because you implement the interfacing logic required for the frontend to even function and run
By and large, the requirement for creativity in UI/UX is difficult on a different level, but both have their own difficulties. For example, imagine giving a frontend engineer a rust application thats interfacing with their UI/UX, and ask them to code it - they would die
Solid_Mongoose_3269@reddit
Data is data and is what it is. Frontend, people can complain about the smallest things.
I can do both to an extent, but I prefer backend. If it doesnt look right, its not the data's fault.
Plane_Quantity_7512@reddit
I'm studying Frontend Development but I kinda find backend easier than frontend just because I don't like to do the design part and it feels more fun when I work with database management using Node and Express. I mean designing always takes most of my time. So, I'd say it depends on person to person.
LocoMod@reddit
They’ve never had to scale it.
huuaaang@reddit
Computers are easier to talk to than humans. There are well defined rules and apis. But people are complicated. UI/UX is hard to get right. And then you have people who don’t know what they’re talking about making demands.
Also, for web dev in particular, the browser makes a terrible application environment. HTML is a document model, not an application toolkit.
kcl97@reddit
Backend is hard but it makes sense and you can do a lot more once you climb over the learning cliff. It takes a while.
Frontend has a shallow learning hill. But the stuff you learn makes no sense because you are just following someone's recipe of how to build *a thing.
Backend is about building foundational skills like learning Algebra. Frontend is about getting things done like learning how to use a $5 calculator from Walmart. Which skill do you think is more valuable, Algebra or a $5 calculator?
Timmar92@reddit
The only thing that feels easy in backend is that my customer usually doesn't care whatsoever how I write it while on a front-end project they have all sorts of inputs
Traditional_Crazy200@reddit
Because they probably havent done backend an completely suck at frontend because they havent put in enough work
splixter512@reddit
Frontend is tough too - backend feels easier to some since it’s less about endless UI quirks.
Time-Refrigerator769@reddit
They can both be very complex, i think backend devs may live longer due to not suffering strokes caused by obscure race conditions in seemingly sychronous code
StretchMoney9089@reddit
Troll post lol
mmcnl@reddit
I think backend has the advantage that inputs enter the application in a controlled and standardized way. In frontend anything can happen and the application can fail in a million different ways, which can quickly become very complex.
Manganmh89@reddit
Because it's hidden from UI most of the time.
some_clickhead@reddit
I think front end is a more specialized skill. Whereas backend is a more generalist skill. Because frontend is always a client facing application, it tends to have a lot of the same patterns. But the fact that frontend is stateful whereas backend is usually stateless adds complexity to frontend.
With backend, you have to know about a bunch of auxillary topics like databases, security (which is of higher importance in backend), caching. There is less of a set pattern for building a backend app because many of them serve completely different purposes.
So if you take someone coming out of a CS degree with a good general understanding of the field, they will have an easier time with backend usually. Because they have that general understanding, but they often haven't developed a high degree of proficiency with any frontend stack/framework.
Forward_Success142@reddit
I’ve heard the opposite, that backend is more difficult, but it’s apples and oranges
BlanketOW@reddit
Probably cuz UI development needs a bit of creativity sometimes?
1tachi69@reddit
Frontend is fucken annoying that's why
CompetitiveAd872@reddit
CRUD BE where the BE is a thin API layer around the DB is easy. But multiple services, multiple auth, cache management, permission management and large scale architecture is tough.
A simple FE can be easy, but an interactive dashboard with live data and realtime comms and handling streaming data can be tough. Creating a proper design system is though. Efficient state management is tough. Threading in FE using service workers can be tough. Creating a large scale FE and keeping it performant is tough.
There is no black and white. Each domain can be simple or difficult. People really should stop worrying about that. Best to learn both and stay agnostic as much as possible.
MosheTDD24@reddit
I always hear that frontend is easier than backend😂 Anyway they are 2 different skills so I don’t think you can really compare
floopsyDoodle@reddit
Frontend people say it because they don't really know what's going on in the backend. I used to think it was, then I learned backend and saw all the absurd amount of effort needed for security and DB operations, and now I'd say they're both difficult in their own way.
Nervous_Translator48@reddit
Backend is usually more elegant. Frontend is a mountain of hacks and workarounds dealing with a document-markup-system-cum-app-runtime that has evolved organically over 30+ years
Wise-Emu-225@reddit
Both can become extremely difficult. Especially over time.
shinobushinobu@reddit
because cope.
ki4jgt@reddit
Backend is straight code. Frontend is user feedback and neurodivergence compliance.
If it were a simple UI, there wouldn't be an issue, but there's an entire loop of split testing, seeing which UI the users respond to best. And a lot of times, it's emotionally driven and counterintuitive to logic.
QuirkyFail5440@reddit
Front-end is more accessible to amateur developers. Backend seems deceptively simple for the type of applications they'd develop.
They have more headaches with their front-end.
They also aren't considering performance, scaling, concurrency, security, reliability, observability or anything else. They just want their website to work when they show it to their friends or their professor.
They are more likely to complain online.
Awes0meEman@reddit
One isn't easier than the other. Anyone who says backend is easy likely hasn't written anything beyond an API that returns unformatted data from a database. Anyone who says frontend is easy likely hasn't built anything beyond displaying a DTO in a grid.
Backend is hard, you have to be very performance minded when writing backend code or else you end up with requests grinding your service down to a halt as soon as you end up with any meaningful amount of data.
Frontend is hard too. You have to account for a variety of screen sizes and you need to ensure that your displays are keeping up with the designs that your designer had in mind. You need to make sure your controls are responsive and keep the user engaged.
Backend is easier for me to engage with because it is something I'm comfortable with and I enjoy the challenges it brings, but I'm under no illusion that frontend is any easier or harder, it's simply different.
Tobacco_Caramel@reddit
Both are just as hard.
FALLD@reddit
There is frontend and frontend, backend and backend
RolandMT32@reddit
It depends on what is meant by "front-end". If it's referring to web development, sometimes it can be a pain to validate with all the various web browsers people might use, which can make it tedious.
tom_yum@reddit
Probably because you can use a language that isn't JavaScript, and you don't need to deal with web browsers.
Puzzled-Usual-566@reddit
JavaScript sucks to debug though
TrickedOutKombi@reddit
I am fullstack so I enjoy both. Backend is pretty straightforward most of the time. Building a front end with nice design can be quite a tedious task that can take quite a bit of time to achieve. However, to me, frontend can feel more fulfilling because you actually see the changes as you make them.
Science-Compliance@reddit
Frontend is more than just the window dressing. You can get into complex logic on the frontend that is really only "visible" in the same way that backend improvements are visible--through performance testing.
nuggex@reddit
I don't think either is harder as such but usually the product owner or client makes the frontend a PITA since nothing is ever good enough, move the menu 5px, the font is 2% too small, the green color isn't green enough, why doesn't it do what site X does and so on while they don't generally know or care what goes on under the hood.
willbdb425@reddit
I have actually somewhat seen the opposite sentiment, that frontend is barely real programming/software engineering and people who do it do it because they don't have the skills for real work. That's of course a dumb opinion but ime more common
the_mvp_engineer@reddit
Never really heard that, but as a backend developer, sometimes the front end with these JS frameworks seems like some kind of magic ass shit and I've never gotten the hang of it.
Also with the backend there are often a few different ways of doing things, but with the front end I feel like there are a MILLION ways to do the same thing, from how to organize JS to how to locate things with CSS...I dunno...it's not for me.
I like the python philosophy of "there should be one obvious way to do things", but in JS it feels to me as though the philosophy is "Be yourself. Carve your own path. You can be anything, so be how you want and want how you be 🕉️❤️🌺🌹✨ Namaste✨❤️"
mateus_6504@reddit
It always depends on the kind of backend. If an app requires microservices, scalability, performance, low cost, etc. That is not an easy task compared to fronted. But if you only need a simple CRUD app, i can see why someone would say that
Inside_Ad6628@reddit
I just enjoyed backend more. I loved the to print statement my way through problems. It was good to see your front end stuff update before your eyes part by part though.
fntn_@reddit
The only people who claim backend work is easy are the ones who've never built anything complicated. The same is true for frontend work. They bring different challenges in different ways, and different people will find those challenges easier or harder to deal with, dependent on the individual.
BamBam-BamBam@reddit
Because you dont have to interact with those pesky users. /s
mexican_restaurant@reddit
I think easier is the wrong word. What they may mean to say is “more straightforward”.
In frontend work you’re constantly in grey areas for “how much spacing this thing should have”, “what colors are right for this”, “is this wording ok or should it say something different”, “should x have a transition”, “how do we want to handle errors here” etc etc etc.
In backend work if you have the requirements laid out for you in a ticket, there’s usually a pretty clear path on how to implement in most cases/codebases. Now there may be other things to consider, how to structure your code to do x y and z but as far as actually getting the feature to do what is intended I think backend work is almost always more straightforward.
DavidWtube@reddit
Backend:
"You got it working? Great!"
Frontend:
"It's works, but could you make it a bluorange tricircle?"
targrimm@reddit
No pixel pushing. Function over fancy.
Snipercide@reddit
Back-end is more technically complex, with a higher entry barrier.
Front-end is more creatively complex, with a very low entry barrier.
They both have unique challenges, and overlapping ones. They're both full-time roles.
Technical complexity is more respected in engineering fields... therefore front-end is a little less respected. It is still respected, just not as much as back-end.
Saying front-end is equally or as "hard" as back-end, is often just used as a virtue signalling statement.. "Let's 'empower' front-end developers, so they'll buy into our low effort Udemy course."
It's just a dumb statement that overlooks context.
Hard or Easy.. It depends on what level you're performing them at. Both can be super easy, or super complex.
Ultimately I do not think the most complex front-end is close to the most complex back-end.
The simplest front-end, and the simplest-back end... probably about equal.
Bensal_K_B@reddit
Totally depends on the project. But it's true that frontend has too many variables while developing like user interactions, navigation flows, api integrations, validations, session logics. And backend has too many variables while upgrading. Its more like a long term problem
PlanetMeatball0@reddit
Not sure who you're talking to that says that, usually if anyone says one is harder than the other it's backend. Frontend is seen as the simpler of the two by the majority of people
Ronin-s_Spirit@reddit
Because I'm not an artsy guy like that, it's easier to write calculator logic than to come up with the look for the piece of plastic holding it together.
RonaldHarding@reddit
Backend is easier for me because through my career I've spent more time development experience and skills relating to backend. For my colleague's who primarily work on fontend, backend is cryptic and strange. In a lot of ways the development philosophies and best practices have diverged quite a bit between frontend and backend. So, unless you consciously work at building and keeping both skills current you're likely to find yourself dreading working on one side or the other.
xabrol@reddit
Because they think back end means, simple crud api on a high level db layer like entity framework. And if that's the case, it is eadier.
But most the time, its not, and its harder.
And modern tooling like vite has made FE brain dead easy imo.
Bunnylove3047@reddit
As someone with ADHD the backend is easier. I find myself getting distracted and frazzled dealing with the front end. I spend too much time tweaking things over and over that were probably fine to begin with. With the backend, it either works or it doesn’t. If something isn’t perfect there, not many people will notice. When it comes to the frontend the whole world notices.
Teninchhero@reddit
I think it’s mostly said by people trying to center a div
BroaxXx@reddit
They're two completely different things which makes comparison hard and meaningless
OneHumanBill@reddit
Because CSS was created by sadists for the purpose of harvesting developer souls. I would rather take on the messiest, nastiest, most ambiguous problem with business logic or production issues than ever see another "the whitespace isn't exactly right" problem with CSS ever again in my lifetime.
who_am_i_to_say_so@reddit
I’ve heard completely the opposite.
If anything about frontend is more difficult than backend, is keeping up with changes. Browser features, coding standards, browser support, and frontend frameworks are continually evolving. And at a much faster pace than backend standards and frameworks.
Epiq122@reddit
Never heard a single person ever say this
DoragonMaster1893@reddit
Backend - I have full control of the environment, like I know the machine it is running. More stable languages. FE - mobile, desktop, screen sizes, accessibility, browser quirks, design, new js framework every day...
Backend has it's own challenges which are also complex. won't say it's easier or harder, but it's more predictable
SmellyCatJon@reddit
lol. Says who? All the complications and the magic happens in the backend.
natescode@reddit
Back-end development is less convoluted and mercurial.
Jay_D826@reddit
I’ve gotten just as lost in figuring out what the hell my spaghetti code controllers are doing as I have in figuring out what the hell is wrong with my spaghetti code react components. They’re just different domains and both have the same potential for difficulty
gmdtrn@reddit
Most backend dev is simple CRUD. And a lot of modern front end dev has complicated state maintenance concerns, plus the need to understand a broader set of libraries and tools.
That said, the most complicated work in programming will be at the systems and service level. That’s all backend. But it’s not most backend work.
I will also say this new to me. For a long time backed devs who did super basic work had gaslit Reddit into thinking front end work is easy. And that was the prevailing idea.
tsereg@reddit
You can say that 80 % of the effort goes into creating a user interface. Perhaps that's why.
Rhemsuda@reddit
Probably because their backend isn’t very good. A bad backend is very easy to put together. A good front end is very hard to put together. But a good backend is harder and carries much more risk
Szkita_5@reddit
Not necessarily agreeing with the statement, but a lot of aspects are simpler. Backend only needs to run on your computer. Fronted needs to run on every one of your customers computers, phones, toasters.
JJJJJJJJJJJJJJJJJQ@reddit
Both can be easy and hard. Back end can get a lot harder than front end depending on what you are doing though especially when it comes to performance in systems languages. Look at ffmpeg as a good example. You'll never find any front end even close to that complexity.
ZelphirKalt@reddit
With nowadays artificially complicating everything on the frontend, this could even be true in some cases. If you keep things simple though, the backend has a lot more depth. But also some issues can be moved to frontend or backend, depending on where you want to solve them.
greenerpickings@reddit
I would say FE has larger subjective element. Two sites can have awesome code and best practices, but one can look like absolute shit. That and you usually need some derivative of html, js, and css for current stacks.
BE can be based on one language and is a lot more rigid, especially in the deliverables. Its either the data is there or its not.
vonov129@reddit
You probably heard it in a dream or something
PralineAmbitious2984@reddit
It's not technically easier but the front-end clients are generally dumber and less-technically oriented, as anyone needs a website, therefore way more annoying.
So you could say that backend are easier roles in the sense that you hate your life less.
PositivelyAwful@reddit
The only reason I could think people would say that is because backend development is more "stable" as far as technology goes. The frontend ecosystem is constantly changing into a more and more complex beast because of all the different stacks.
KwyjiboTheGringo@reddit
It's too complex to boil it down to such simple conclusions. Front-end is hard for many different reasons which back-end doesn't have to worry about, and vise-versa. But at the end of the day, either side can shortcut a lot of the common pitfalls by utilizing libraries and frameworks, and that will get you pretty far, and also shift some of the difficulties into learning the pitfalls of those libraries.
petr_dme@reddit
Backend challenge is you need to handle data. Wrong logic might be very dangerous.
While in FE, as long as as BE guard the logic for data, mistake maybe not too severe.
However, good FE engineer might make the user very happy.
Greedy_Ad_1753@reddit
As a senior developer, this is 100% incorrect. Backend is where the "Engineering" in software engineering comes in. It's where the algorithmic complexity matters, it's where distributed systems come in, and where most of the actual processing comes in.
Front-end is difficult in a different way, but there's a reason that these 6 week "coding bootcamps" are pumping out javascript engineers.
Ordinary_Safety_258@reddit
Both can be hard if you are unfamiliar with them. Frontends can contain incredibly complex logic, as can backends. In my experience, finding client or server side code hard depends mostly on your familiarity with both the technologies being used, and the codebase. Once you become more familiar, they become less hard, whether frontend or backend.
The complexity of backends can relate largerly to the distribution of services and their interaction with one another. This requires the ability to store a large, and complex mental model, which can be difficult. Frontends can contain complex physics based animations, or complex state interactions, which also involve having a clear mental model.
Either one requires familiarity with the concepts and the codebase. If you are finding backend code harder to understanding, you'll get there. You just need to spend time reading the code, reading the docs, and learning about the technologies, and things will become clearer. Whenever I am learning new code, I imagine it like a foggy room where everything is hard to read, and over time the fog starts to disappear, and it gradually becomes clearer and clearer. You'll get there.
SandwichDmiga@reddit
I find BE easier to understand because you feel more in control, and therefore know (or not) what's going on, in FE the technology tend to be such a mess of layers that it's just about learning the bag of tricks for that framework in question.
But I wouldn't call it easier, BE usually requires more algorithmic thinking.
DIARRHEA_CUSTARD_PIE@reddit
They hate css and the huge mess of frameworks and modules
WystanH@reddit
Easier? No. More inscrutable? Yes. Backend, by it's nature, is hidden from the user. The user only sees the frontend.
Backend issues are shown to the user via the frontend. This is their only view of the system. Effectively, all issues are frontend issues.
The frontend is also somewhat arbitrary; everyone has strong feels about UI and will happily let you know. The backend has a well defined set of things it must do. CRUD operations are not subject to the whims of user aesthetics.
Beneficial_Steak_945@reddit
Maybe because you don’t have to deal with designers who insist on pixel perfect no matter what?
Anyway: different things. Both have their challenges.
NekoRevengance@reddit
i find backend easier because a client has no say in it.
He can't say move this here, change the color, make the button more rounded, etc.
Only another technical person can shit talk about my backend code.
bunk3rk1ng@reddit
Even if the frontend works great and is super performant you will still have 10,000 people with opinions on what should change. Especially at mid level companies I've seen tons of times c-level people get involved because they think they know better and they need the change made NOW.
If the backend works nobody cares.
annika-of-the-woods@reddit
I don’t think I’d really say one is harder than the other, they’re very different and challenging in their own ways.
But if I had to pick one thing that’s harder about frontend than backend, it’s that you’re much more exposed to the chaos and weirdness of how people behave than on the backend.
On the backend, you can generally tightly validate your inputs then have a lot of control over what happens next in terms of database interactions, calls to other services, etc. Your code only has to work in one environment, with one version of the database, so on so on.
Whereas on the frontend, you might get someone trying to run your app on a ten year old smart fridge, with the language set to Klingon, who then hits the “submit” button on a form 40 times before the page reloads, but still expects your site to do something sensible in that situation.
MagicalPizza21@reddit
Probably because their CS degree programs teach them more back end skills than front end skills.
Efficient_Loss_9928@reddit
Different skillsets.
Backend have controllable environment and controllable release. As everything is managed by you.
While frontend is less controllable. User can be using any client in any environment. They may decide to not update the app in a month.
But backend usually have more components, so I wouldn't say it is easier, just more controllable and deterministic, which is what engineers like :)
billcy@reddit
People always say there job is the hardest
Salaas@reddit
Backend is harder in a technical skill sense. Frontend is harder in a softskill sense.
Clients dont really understand backend so tend to not get too involved so its easier in softskills. However its more involved technically.
Frontend, clients understand it better so you have to have better softskills to deal with them.
oVerde@reddit
The trivial backend popular known as CRUD is way easier than the average Frontend. The hardest Frontend (XR/WebGL/Gaming) is way WAY harder then kubernets CI/CD with gRPC and CQRS mixed eventual consistency and live events on micro services.
Lower_Cockroach2432@reddit
If your backend is a large financial system involved in checking KYC, updating ledgers, calculating fees and taxes and dealing with counterparties, and your frontend is just a bunch of buttons to facilitate this then obviously the backend is harder/more complicated.
If your frontend is a mobile game and your backend is just a leaderboard or a system to sell and store microtransaction based gems or something, then obviously the frontend is harder/more complicated.
Practical_Cup_6583@reddit
Backend only looks easy until your server decides it doesn’t feel like existing today.
randompinoyguy@reddit
I don’t think the statement is accurate but I can see situations where it might feel true
For one, frontend is what the non-tech people see so they can comment on the smallest detail with vague things like “make it pop”, “it doesn’t feel right”, etc. Backend, for them, just needs to work quick enough
Another could be user feedback. Same as above, users can’t see the backend. Any slowness or errors from there are seen on the frontend
Both combined could result in more tasks and longer back and forth between dev and other stakeholders, which could lead to stress, and therefore “harder” tasks
LivingHighAndWise@reddit
Backend is easier because most of the time you are developing to a defined set of rules and data inputs. When developing UIs, you are dealing directly with humans. Humans are agents of chaos. Even if your UI is error free, has proper field validation, and works perfectly, Humans will find ways to inject chaos into your system, or simply reject it because of personal preference, or utter stupidity. When you couple that with the wide variety of devices and browsers you have to develop for (Edge, Chrome, Firefox, PC, mobile, etc...), it becomes clear which is more difficult.
Agreeable-Bug-6941@reddit
They are right. It's a myth that backend is hard. Frontend is a thousand times harder. I'm a full stack developer who started with frontend and I was so scared of backend until I realized backend is super fun to work with. For example; can't get an output from a function? Just put console.log(). Frontend is very frustrating and mostly it's the frontend that gets you tired and leave projects. Frontend is not just designing the application. Even frontend has backend like scary looking files known as services, etc and huge non design code (function coding, data handling, error handling). One small error in a single line will make the entire interface not render. While backend has lots of debugging tools already.
Familiar_Bill_786@reddit
It really depends, I would say backend is easier if you have a good understanding of how the business logic for the thing you're making it for actually works.
No-Arugula8881@reddit
Business logic is the easy part. If you think it’s the hard part, then you have only seen the most basic of backends.
PineappleHairy4325@reddit
Highly project dependent and, in most cases, difficulties of a different nature.
Vozer_bros@reddit
Most BE SE are scared of CSS.
Most FE SE hating setup a database.
Guys talking about get a piece of data and send to it's client. Yes, it is easy!
But, to combine BE, make performance query, use CND with access management, Containerize, auto scaling, message broke, security......
=> For me all of that shit define a senior BE engineer, and it is art!
harrygermans@reddit
I personally find backend to be more straightforward. That doesn’t always mean easier of course, and of course it depends heavily on what you are using them for.
Building a backend generally requires more foresight and understanding of various technologies so it’s more complicated in the beginning. But when I worked for companies as a full-stack dev and the systems were already in place, I definitely found the backend work to be more intuitive and less painful
But I also hated working on frontend so I got frustrated with it more easily and steered myself more towards the backend. So definitely biased here
explicit17@reddit
That's usually otherwise, but not true either
Potential_Copy27@reddit
Basically - If you make a mistake in the front-end, everyone in the world is going to see it immediately. Especially the "nasty" hacks you made in the project.
Front-end requires a bit of graphics knowledge as well, how screens/browsers draw things, how to scale etc.
Back-enders can slack off with these things without consequence, because nobody notices apart from themselves and the error logging system (which you made sure to implement).
I've made and supported stuff in both ends, at least that's my experience. :-)
That said - front-end isn't that much harder, but you need to be a bit more perfectionistic about things....
Eskamel@reddit
The only times frontend can be considered to be complex are when non DOM related behaviors are required without available external libraries, or when you need to have some performance improvements
On average, the front is just a mish mash of preexisting libraries, there is very little engineering involved in that
MonsieurCellophane@reddit
People saying things
barraponto@reddit
Neither is easy, but frontend complexity has no limits.
AvailableBowl2342@reddit
Front end feels like i have to read and learn about too many different subjects before i get to write and play around with some code. Which just really kills all the fun. Too many libraries, frameworks and tools you have to master and keep track off. Everything is constantly changing, and there is new stuff introduced constantly.
I dont think the coding part is really more difficult, and im sure if you have years of experience(i.e. senior) the constant having to switch is more of an inconvience. But if you are a beginner its a handicap and very demotivating, also hard to decide on what to prioritise to learn first.
Lauris25@reddit
I think it depends. (Junior dev)
Both can be easy and hard.
In my opinion, backend has more pattern, structure? Frontend can be chaotic. Try to fix some frontend bug with 50 tailwind classes on deep nested component. Or when the advanced animations, layouts come in.
On the other hand backend is more important than frontend. You have a bug inside image gallery? Who cares, its not even priority to fix.
It depends on the project. Mby client wants advanced almost static page with simple admin panel to post blogs, but with very advanced animations/visuals. Mby client wants simple looking online store, but with advanced backend.
No-Arugula8881@reddit
People who say frontend is harder have probably only worked on frontend-heavy projects with the simplest backends. Frontend is also easier to slop-up via AI.
deez_nuts_07@reddit
Bro all the application logic falls under backend and literally all the processes are integrated by backend Idk how that could be easy...
hoochymamma@reddit
No one said that
humbabumba420@reddit
I think it depends on the person? I think frontend is way easier than backend development. I don’t like pipelines and I never will, I’d rather push pixels for the rest of my life lmao
alexbottoni@reddit
For two reasons:
You have to deal a lot less with the end user and the customer...
You can avoid Javascript...
1knowbetterthanyou@reddit
Because of css
JonesOnSteriods@reddit
Depends on the person right? I hate UI stuff, I prefer backend. Not saying it’s easier. It’s just a preference.
Ashamed-Violinist460@reddit
I honestly thought this was a question about sex until I read the replies 😳
boisheep@reddit
Because frontend is what the user sees, it's what the manager sees, it's what HR sees; the one and billion feature will be pushed and described as frontend, even if it is backend, if there are changes pushed by design team that are contradicting it will be in frontend.
As a result even complex backends can be pretty organized, while even simple frontends are a complex mess of contradictions and struggles of what the user wants, what design wants, what your boss wants, what you want and so on.
It has nothing to do with technicality, it's why a sales job can be more difficult than an engineering job; you are far more exposed to the user.
freakytapir@reddit
Back end just has to work, front end has to please the fickle whims of the customer.
barkingcat@reddit
It's cause the kind of people who usually do development are more backend people.
Tell a technical designer to pick up frontend dev and they'll say it's easy, but say backend is completely incomprehensible.
It's all about the kind of people who are commenting, and backend people tend to comment more. Frontend people just draw.
AccurateSun@reddit
I think the difficulty in frontend comes from the large range of browsers and devices (of different types/ sizes: mobile, tablet, desktop) that you have to account for. Your code always runs on machines that you can’t control. It’s complexity depends on what kind of frontend you’re building though
Backend can be very simple all the way to very complex as others have commented
ZubriQ@reddit
I find it otherwise
nedovolnoe_sopenie@reddit
i can code in assembly but can't code in rust.
for me, assembly is a lot easier than rust, then.
i think that's how such statements come to see light of the day.
Big_Tadpole7174@reddit
Never heard of it and it's totally nonsense.
Prestigious_Water336@reddit
I've never heard that before.
Front end is more user focused as it's what they're interacting with.
Ok_Interest5162@reddit
lemme guess an Architect said that ? XD
But seriously I never heard anybody say that. Also something bein easy is highly subjective, because some people are naturally better with certain skills. Those skills may apply better on Frontend or Backend. Therefore for that person Backend might be easier because the skills needed in that Backend environment is what he´s pationate about and therefore it´s easy for him.
While for somebody who never coded before Frontend and Backend are equally hard.
Pochono@reddit
I don't know who says that. They're just different skill sets.
Feedback loop is different tho. Back-end, you get yelled at when stuff doesn't work, but they don't care how you did it. Front-end, everybody and their mother has to inject their opinion. On the other hand, front-end gets first credit (on the rare occasions there is any to give) but also first blame (but that can be passed easily to back-end).
A_random_zy@reddit
I find FE boring so it automatically becomes harder for me. I find BE interesting so it automatically becomes a timesink for me
TheChief275@reddit
It isn’t easier; it’s just a preferable experience. Programming frontend is something I’d rather never do again. Only web though, e.g. a compiler frontend is actually really fun
_warthog_lover_@reddit
IMO they each have their own difficulty curve that’s somewhat different. I’ve been working exclusively on FE the past couple of years and generally I’d say what’s different about it is having to account for user interactions and experience as it is the layer that… well, users interact with the most and are most likely to end up having unintended interactions with
InternetSandman@reddit
I think this is a matter of personal preference. Both camps may find the other to be problematic
Front-end devs may find the complexity and business logic of back-end too much to comprehend, and too difficult to implement efficient solutions or track down bugs. They may prefer the more free-flowing feel of the work. They may also be more visual focused (i.e. I change something in the CSS and immediately see the results on the page)
Back-end devs (the camp I would most identify with) probably find CSS and JavaScript to be maddeningly imprecise tools with a painful amount of arbitrary rules and gotchas. Working with Java, C++, or Rust for backends will give you a lot of organization and structure that those frontend languages simply don't have. Personally, I also find working on GUI stuff to be more boring: I want to get at the core of something and make it faster or more featured from there.
TornadoFS@reddit
All projects after a certain point become impossible to be fully understandable by a single person. But in the backend it is a lot easier to split things into smaller modules that are fully understood by their maintainers.
Because splitting frontend into modules is very difficult and very leaky (as in, problems in one module can cause problems in another unrelated module), you often need a fuller understanding of the whole system to be able to make changes to it than you need in backend.
The hardest problems to solve are cross-cutting across multiple modules, they are far more likely to happen in frontend development (especially in very stateful frontends). You have these kind of problems in the backend as well, but they are usually rarer and easier to _detect_ because of all the monitoring tools available for microservices.
These kind of cross-cutting problems in backend development are often are harder to fix though. Part of the reason is that backend developers are often incentivized to "silo" their development and avoid "crossing" their module ownership boundary. While frontend developers need to have fuller understanding of the whole system to get anything done.
Backend used to be more like frontend before distributed microservices became a thing, the monoliths of old had many the same problems as modern frontend development. While backend people managed to split the complexity up by chopping it into network-separated modules, frontend is still treated as a monolithic piece. It is a lot harder to apply the same techniques to frontends for various reasons (lookup microfrontends).
So in short: Frontend people need more knowledge of the whole system to be effective, Backend people don't. Neither is generally harder or easier, but the barrier to entry is higher in Frontend projects.
Kpow_636@reddit
I find them both equally hard lol. I get stuck and frustrated in both all the time. Other than that, I don't see much of a difference. It's all just a bunch of words on the screen at the end of the day.
8dot30662386292pow2@reddit
Well for me it's like this. Backend is just numbers and logic. Frontend is also design work on top of that.
Though I can make a shitty UI easily. Code is just code. But making it well is the problem.
Logical-Idea-1708@reddit
Backend is more segmented. Systems are separated into layers. Diagnostics can be traced layer by layer.
Frontend is all tangled up. You have your HTML into your JavaScript and CSS in JS. Webpack loaders are tangled up with your app code. You don’t see compiler leaving traces of itself in backend code.
wirrexx@reddit
It’s a prefer
Elegant_Mongoose3723@reddit
it depends on the project and your interest. Both can be tricky
Cryophos@reddit
I am afraid someone was drunk when he said that. Backend is harder definitely.
Veurori@reddit
I think it depends where you start and what language you choose for your learning path.
Hot_Dig8208@reddit
I think both of them is different fields, so it is not comparable. Don’t start arguing about backend vs frontend. Learn both of them, just my two cents.
OpportunityThin5118@reddit
I dont think its correct because in backend you have to use your algorithm abilities + coding skills + Integration etc. But frontend for me only you see you code spontaneously then you check for front side if you write the code correct or not 😄😄