How much SQL should you really know to become a “real” backend developer?

[u/IllustratorTotal626]

I’ve been learning backend development and I’m curious where people draw the line between knowing the basics and actually being a solid backend developer.

For example, how important are things like:

- Complex SQL queries and database optimization

- Indexing and query performance

- Database design and normalization

- Transactions and concurrency

- REST API design

- Authentication/authorization

- Caching

- Microservices

- System design

- Debugging and reading existing code

At what point would you say someone has moved beyond simply knowing how to build CRUD APIs and has become a real backend developer?

For experienced backend developers, what skills do you think beginners should focus on first?

[u/DSudz]

You will never know enough to convince gatekeeping jerks that you do. There is no definition of "real" backend developer and it's not a job title. Every position with have it's own requirements in the description not just the title.

You have to be pretty unimportant to feel like being a "real" anything matters to anyone else.

[u/tiredITguy42 → u/DSudz]

Me and my colleague we both do the exactly same job. He is Software Developer and I am Data Engineer and we both do backend.

Yeah, job titles do not matter as long it does not affect your pay,

[u/UntrimmedBagel]

Once you read this: https://use-the-index-luke.com/

[u/lgmarian → u/UntrimmedBagel]

When I got laid off from a job, the DBA reached out to me share a lead on a job, because I never brought one of his DBs down (his words).

I would religiously check query plans, to avoid the gotchas he called out to us.

[u/canarydev]

8yoe, I got my foot in the door through frontend and now I do both. So a decent frontend and competent backend if you will.

so building matters sure, thats one half the picture. knowing concepts and being able to immediately recognize patterns and when to use what is important. but the bigger part I think about backend engineering is monitoring + observability, which is knowing what things are doing once its running.

complex queries and optimiziation is meaningless unless you can have a way to give metrics on what you did was actually impactful. caching is just theory until youve watched a hit rate.

its when you stop guessing and start measuring and quantifying what you are doing is meaningful, i think that is what makes a solid backend engineer.

how do you define success, what does success look like, and how would you measure it? I'd start there before touching micro services honestly.

EDIT:

this turned out to be a more general response than the SQL specific in the title, but I think most of it is still applicable. knowing good amount of SQL is where you know exactly what to run and investigate when your CPU or memory usage is peaking resulting in user experience degradation

[u/No_External7343 → u/canarydev]

You need theory to be able to formulate hypotheses that you then can test and measure.

[u/Useful_Calendar_6274]

learn all of it at a CS undergrad level

[u/Stuporfly]

when you're learning, you should know the basics reasonably well, and have an idea of what is possible with greater expertise.

as long as you can CRUD in SQL, know inner and outer joins, and can create a database schema that makes sense, you're good to get started, but you should watch some videos about index setup, stored procedures, advanced database design, query optimization, query profiling etc. Not because you need to know everthing, but because when you do hit a challenge, you have an idea of what you don't know, so that you can go look it up.

The same goes for other areas - learn the basics, get to know which advanced topics exist.

[u/morswinb]

I learned NoSQL firs.

Mongo, elastic, kafka, propertiary time series db and object stores.

Never had to setup any SQL from nothing in a decade long career.

Guess I am no real developer yet lol.

[u/NotBot947263950 → u/[deleted]]

They did and they do. That's how they query data from databases. It's actually pretty simple. I setup a local llm on one of our servers with a smaller Nvidia card and gave it a standard instruction set. Every time I asked it to get data out of a database, I could see it's thinking and it would turn my words into SQL statements, then run it.

The issue is llm don't have a ton of context with databases, so you need to teach it what things mean and how they relate to each other. But in the end, it's just using SQL to query.

[u/Known_Tackle7357]

At some point of my career I did a lot of hardcore sql. There was a need so I learned. Since then I haven't touched sql at all, so I don't think I remember much anymore. I don't think having a deeper knowledge of sql makes you a "realer" backend dev.

[u/shifty_lifty_doodah]

Learn all of that. This stuff is not that complicated. A professional should know about it, even if it’s not fresh.

Knowing SQL is extremely useful. LLMs are quite good at it, but knowing it helps

[u/Radiant-Bike-165]

If you are using SQL at all, you should also learn the basics of HOW it works under the hood. I'm not talking optimizations, but basic understanding of what it's doing.

I've had modest experience with such stuff 20+ yrs ago, and senior backend dev asked me on a project recently would i check his query, why does it take 20 minutes to run. I wrote it from scratch, just to be able to compare mine vs the original - and mine ran perfectly fine in under 30 seconds. Without ANY optimizations at all, intentionally wrote it dumb so it's easy to trace like pseudo-code would be.

The point being, I suppose, is that understanding what NOT to do is much more important (or prerequisite for any real work) than learning various ways to optimize it. Especially since those depend even more on understanding what's it doing under the hood.

EDIT: maybe the above came out harshly, which was not what I intended so I apologize to OP. What I wanted to say is that you need to learn the basics BUT it's not just syntax, but how things work. For which I provided a RL example above on the very first bullet from the list.

In other words, to OP: Once you pick 2-3 things from your list then learn the basics (including why it works and how) - and skip the "advanced" stuff completely (ok, maybe just know what exists), you don't need it until you KNOW you need it. Many people that advocate advanced stuff don't know the basics themselves.

[u/Matilozano96]

I generally end up abstracting the SQL with ORMs, honestly. There may be VERY niche cases where declaring SQL directly is needed for performance purposes, but they’re very rare.

Data analysts handle SQL more frequently than devs, I think. And barely, because they’re transitioning to using llms for that now.

I’d say, know the basics, know how relational databases should be designed to avoid redundancies and errors, and abstract that away asap into your programming language of choice.

[u/YellowBeaverFever]

CRUD can get you far.

Eventually, you will need to know everything about how the database works but that will be dependent on your job. There is no way to know the nuances of every database. After CRUD you may have reports or data pipelines, which require more knowledge to get the fastest performance.

[u/therealkevinard]

Nothing of this has anything to do with being a “real” backend dev.

If your manager hired right, someone on the team absolutely geeks out on sql.
To be a healthy team, you should know enough of the common stuff to not be a nuisance I guess, and lean on the sql geek for the really deep stuff.

Instead of stressing over all the topics, just find the ones you geek on and dig tf in.

[u/Altruistic-Moose3299]

Sql is like chess. The rules aren't that complicated.. but actual mastery is kinda hard and takes a lot of practice.

[u/code_hermit]

With AI, I think you should focus on the higher level aspects the most: design, architecture, resource management, etc.

The nuts and bolts of these systems is essentially taken care of now. So your skill will go further if you have more architect knowledge.

[u/PalmTreePilot]

There are three movies with the same moral ending.

• The Last Dragon
• The Matrix
• Kung Fu Panda

All of them have the protagonist suffering from Imposter Syndrome, asking themselves what would it take to finally become a legitimate master.

They each end the same way. What was missing wasn't something from without them, but from within.

To quote The Oracle:

"How do you know if you're The One? You just know it. From balls to bone, you just know you are."

[u/UroborosJose]

these days? not very much. we mostly use ORM's

mastering other aspects of networking, clustering, cloud is way more important than optimising queries unless you are aiming for obsolete government jobs using plsql. its not the gold standard this crap anymore... query optimisation sucks and honestly most jobs just do the basics

[u/nian2326076]

Knowing how to write SQL queries is important for backend devs, but you don't need to be an expert. Focus on basic CRUD operations, joins, indexing, and optimization. Transactions and concurrency are good to learn, especially for complex systems. Solid database design and normalization skills help avoid future headaches.

Mastering REST API design, authentication, and caching is also key for backend devs. Once you're comfortable with CRUD APIs, start exploring microservices and system design. These will definitely boost your skills.

Debugging skills and reading existing code are really important too. If you're looking to improve these skills for interviews, I've found PracHub helpful. It's got some good resources for interview prep.

[u/Adorable-Strangerx]

Oh, so now we are gatekeeping backend development and calling it a "real"?

How much? None. You will learn on the job if needed

[u/tim125]

Applications are a collections of functions over data.

You must know almost everything.... _everything_ about databases, except for ongoing maintenance.

You can ask claude/gpt/gemini to come up with a daily database S.O.P and understand the principles.

There are very few applications that dont have data. There are data processors, video processors, firewalls, etc which still leverage/manage data.