Juniors write a lot of code. Often significant amounts for a company's products and services. They're the ones who are implementing all the decisions that seniors spend their time making in all their meetings.
Most senior engineers I've seen have most of their days filled with meetings with very little actual coding time.
The seniors are valuable, making decisions, coming up with solutions, building frameworks etc, but it's the juniors who then take that and run with it and build everything on top of it.
So while some will still code, it's far less than what the junior engineers are creating.
Yes they require some more training, and clear direction, but they are the ones actually creating and executing the vision of the company informed by the seniors.
What companies really want, like others have said, are senior engineers who are willing to accept a junior salary.
While of course companies would love senior engineers willing to accept a junior salary I'd say
> Most senior engineers I've seen have most of their days filled with meetings with very little actual coding time.
Is actually a symptom of the shortage of senior engineers. Big companies that can afford to hire as much talent as they want actually will let seniors write code all day (my company does) because they have the economies of scale that lets them afford doing so; no one else can.
This is laughably false. The highly-paid, experienced seniors produce so much more value than juniors that it's not even in the same ballpark. It's also usually the kind of value that juniors don't even notice, because it's not measured in lines of code.
A good junior will write a hundred lines of code in a day. A good senior will delete a hundred because they realize the user dictated a solution instead of detailing their problem, asked them, and figured out that they can solve that problem by changing a config variable somewhere.
Where have you worked where senior engineers do hardly any coding? What else would they do all day?! Are you sure you aren't thinking of project managers?
Everywhere I've worked (mostly large companies) the seniors write much more code than the juniors.
Because they are two different jobs usually. Juniors are more focused on code while senior trends towards planning, reviewing, and leading. In my experience a senior is just as likely to spec out some work and pass it on as do it themselves.
A junior is an engineer that has less than 2-3 years experience professionally, and about the same time building and learning how to code by themself on their spare time.
An Intermediate engineer is a Junior engineer with a good attitude - that says: I am still earning, and I am humble, and I listen more than I talk.
A Senior Engineer Has 10+ years of experience coding, and developing solutions.
He has navigated all the corporate BS, politics, and quit several teams of arrogant Junior con artists, or poor project managers - and is tired of all this BS. A real Senior engineer can code the entire solution by himself in 6 months , instead of a team of 5 juniors over 2 years.
A real senior engineer - worth 10x the salary of a junior, and at least 5 time the one of his direct supervisor - for one reason:
You can remove everyone in the product team that doesn't have at least 5 years of experience developing code. And you will have better results at delivering your product.
In your case, you probably will end up with zero employee.
Now how much money are you offering this Senior engineer?
Will you pay him/her the equivalent of the whole team you just fired? Or just advertise a "competitive (LMAO) " 170k$ package with amazing bonuses...
Which is like what.... only 40% more than the Junior that costs more time than it actually saves?
Maybe start respecting what it means to be a performant senior engineer - Most of them died of depression, burnout - or jumped in the management wagon - because they were too tired of corporate BS and saw no points in even remotely trying to deliver technical solution in an environment where they don't have decision power - while at the same time - nobody in the hierarchy above (and under them) slightly understand the blueprints.
When you realize the value of this rare person, you can think of multiplying the salary package by at least 3.
Then, you can do your interview rounds.
The heck! if I ever want to work in a tech team again - that either will be at a market salary (understand getting paid 5 times less than what I technically worth) for an ethical projects - which is rewarding for my soul and self respect - OR - I will get a 500k$/y for a basic coder job at Google/FB/etc.
Maybe you are not looking for a senior engineer, maybe you are looking for an intermediate one.
If you come to hire a senior engineer at that salary, be warned: he's not a senior.
I haven't seen many junior engineers write code I was particularly impressed by, or that could stand the test of time. It's more tech debt, but it's also learning. Others here have said a mix of junior + senior is ideal, and I agree. But for some things, you need speed and low tech debt: those projects are when you should lean more heavily on your senior staff.
Junior engineers willing to burn themselves out doesn't bode well for the quality of work you're getting.
Agreed. The "value" of the senior engineer is not that they write code faster than a junior. The value they bring is that they level up a team. They hire well, they provide mentorship, they help the team avoid making time-and-money-wasting mistakes.
Yeah in my recent experience juniors are people who don’t know basic engineering yet and seniors are people who can actually complete a task in their own (with most still having little knowledge of actual advanced programming concepts.)
This is what an industry of outsourcing to “contractors” has done. Companies that aren’t ran by tech people have no idea how to actually hire tech roles and are trusting the contracting firm owners, who I’ve found also have little knowledge how to hire for tech.
Excellent answer. I think the real difference between a junior and a senior is not so much in coding skill; some juniors are really brilliant coders and can fix any problem you throw at them.
But a senior has more experience with the "why" behind the coding. What are the requirements in terms of schedule, user experience, stability, maintainability, performance, development process, QA, etc. A junior can be great at one of these, but a senior has to take responsibility for all of them. So you need to understand the needs of all the stakeholders outside the dev team. (At least the basics; functional details deserve an expert of their own.)
In my experience a great way to hire and train juniors is to have them do tasks that need to be done but you can’t over allocate or reallocate an existing engineer for it. Like refactoring existing code.
Why? The only guidance then a more senior engineer would need to give is during code review and where they may have questions. It’s a great way to get them familiar with the code base and train them up. I haven’t seen this be a productivity killer.
Also, with the shocking frequency I’ve seen, code based need more tests. Have them write tests! That’s a fast way to get up to speed.
One other point: senior engineers in one code base may have an uptick if a “junior” in another depending on existing quality, circumstances etc.
I think organizations are lying to themselves that they can only hire seniors. It’s a myth. Just like 10x developers.
I need hard data to be convinced otherwise not anecdotal evidence. All the hard data I’ve seen points in the opposite direction of any anecdotal information I’ve come across.
There are so many volumes of books devoted to these topics alone that I think most ideas around developer productivity without the firm backing of numbers are mostly hand wavy and myths we tell our selves to feel better
Some companies tend to hire only junior devs for junior positions. The argument is that, once hired, senior people complain about being paid lower than a less experienced dev. Some management does not want to deal with that. I know it sounds stupid, but that is what I've heard from some of my seniors.
I see it the other way around the senior engineer is expensive and costs a lot 2 juniors are cheap. Who cares if their code is crap they produce it really fast so they find a bug, just fix it quickly. If anything the time a Sr. spends thinking about things to do things "right" is seen as a waste of time. Whereas the jr. will produce an enormous amount of buggy code but they can fix the bugs quickly by just throwing another prompt to ChatGPT to solve.
Now some might say that the code will be terrible quality and buggy and full of holes and the users will hate it, it is never economically viable to build enormous systems on a house of cards like that. To which I respond, you just described every piece of enterprise software I've ever used ever.
Junior developers are junior developers: regardless of whether they've been coding since age eight, started in college and graduated with a CS degree, or bounced around odd jobs before doing a bootcamp, you can't let their code near production without substantial oversight from more senior developers. (I fit into the first bucket and it is frankly amazing to me that they let me touch a keyboard at all in my first two years in industry. I used to pronounce projects done which did not compile, as a result of "just one quick fix" on the last day.)
Engineering organizations either a) understand this fact and build teams around it, b) accept that their salary floor is now +/- $140k or so (in Silicon Valley), or c) whine incessantly about the engineering shortage.
- I really didn't like that seniority equates to creating value in this article. I knew junior engineers who could have code circles around way more senior.
- Comparing Bootcamps with CS degree is also leaves a bad taste in my mouth. Bootcamp is usually much shorter and very narrow. CS is longer and much broader. Software engineering became complicated enough to require some breadth (even junior engineers need to have some understand of SDLC, source control, language, main framework and couple of other things).
- On another hand, I agree, everybody wants senior people, because senior (+good) engineers create way more value than junior (and unproven).
- I think for junior engineers who don't come from the top schools it would be hard to get into a pipeline of hotshot companies. However, why do we concentrate on FAANG as a first employment opportunity? The first company where I worked had 5 people and a dog and a tiny salary. It didn't stop me from finding the next company and gradually getting to a decent place.
- If I was in junior engineer shoes, I would try to find absolutely non-glamour company (big old consulting company, something small and local, government, etc, and apply there). Get a couple of years of experience and after, expand the search to include better companies.
Also, I would challenge the core premise of this article, looking for Junior Software engineer, I got around 700 open positions and searching for senior, I got about 900.
Junior devs are a radically different value proposition than senior devs. You have to turn them into good developers, they will all look like garbage on paper if you are expecting someone who can walk in and do the job. Curiosity, tenacity, demonstrable coding experience (even if it's side projects), and interests/hobbies outside of tech seem to be the best predictors for us in hiring juniors.
Without any data and based on the juniors I met, they pour out way more bugs right out of the gate and the code becomes really bad if not kept in check.
That's a substantial difference between a junior and a senior.
Of course this is dependent on technology and company onboarding and the codebase, so it's really haed.
But also a junior comes trained in one programming language, maybe two, and you encounter many different requirements that might exclude juniors. For example Company uses Elixir, no junior is trained in that, a senior polyglot will learn very fast,a junior might have problems.
Juniors do most code, seniors less. Those who work on easy tasks produce most code, those who work on hard ones less.
And then there are usually senior positions where producing code is just part of your responsibility - compliance, analysis, negotiation, architecture, operations, troubleshooting shooting.
In addition, I think it's the fault of management if it's all young engineers.
I've often said the difference between a senior and a junior isn't writing software successfully, it's writing software that's maintainable 5 years down the road. The only way to learn that skill is to deal with a project over years and learn the pain points that aren't immediately obvious w/i the first 18 months.
Juniors write a lot of code. Often significant amounts for a company's products and services. They're the ones who are implementing all the decisions that seniors spend their time making in all their meetings.
Most senior engineers I've seen have most of their days filled with meetings with very little actual coding time.
The seniors are valuable, making decisions, coming up with solutions, building frameworks etc, but it's the juniors who then take that and run with it and build everything on top of it.
So while some will still code, it's far less than what the junior engineers are creating.
Yes they require some more training, and clear direction, but they are the ones actually creating and executing the vision of the company informed by the seniors.
What companies really want, like others have said, are senior engineers who are willing to accept a junior salary.
reply