that is true for firms that never hire juniors. For me, I have a small team, we can only absorb a small number of juniors at any given time, because I have to have people free enough to train them up. And now, having lost most my seniors in my team to attrition, I'm hiring more mid-level developers (and hoping to find seniors)
That was exactly my point. But why hire & train a junior dev when there is no company loyalty and the money spent on training is basically lost. Instead management focus on directly hiring seniors. Of course that doesn't work as a whole, because if no one hires juniors there will be a point where there will be no seniors anymore. I also feel little to no pity when those companies complain, that they can't find seniors.
Junior devs are significant drain on senior devs resources which could otherwise be spent more productively. And once he or she matures a bit, he or she gets hired somewhere else as senior for double the money. Thus hiring seniors and not bothering with juniors have obvious business sense (until there is a way to bound juniors somehow - for example by immigration).
In my experience, I've found that if you are a small company or don't have 8-10 seniors, hiring juniors is extremely risky, specially if you are not in the U.S. (or anywhere you can't fire them instantly when you realize your mistake).
One junior per 10 mid level to senior devs, and they can add value (given they are good) without taking anyone's time significantly.
One junior for 5 seniors can still work (specially if you arw a much bigger company and can move the juniors to different teams), but be prepared to have times where one of the seniors is spending way too much time with the junior... but hopefully, in a year or two, the junior will be mostly independent or at least will learn how to make best use of their time they spend bothering the seniors... if they don't leave the company in that time, that is, which they most likely will do because someone with a +1 year experience becomes much more valuable, specially as a junior.
This advice is too generic of course. I have also encountered juniors who have been a pleasure to work with, who will make sure to listen, understand and incorporate your ideas in a fast-paced way (juniors have the advantage of not knowing or caring about ALL the different things) and come back to you prepared with the right questions to make the best use of your time. But then these are not very common.
This is bogus. Every week I'm interviewing a handful of people for internships and junior roles.
This is also simply not true:
> top companies (big tech, high growth startups) figure out that they don't really need to hire a lot of junior developers, they'll just hire the best seniors from other companies
Not only it is insanely hard to hire senior devs, but also this doesn't make sense. We have plenty of work to go around and not all of it is at the senior scope. There is always room in big tech to hire and train juniors.
Worse, many firms are put off by juniors for entirely preventable reasons. In their minds, juniors are undesirable because the moment they are trained up, they tend to jump ship for senior positions elsewhere. Why train your competition, right?
The reason they jump ship is because the firm refuses to re-evaluate them for what they are worth, and keeps them on work meant to free up the company's existing senior staff (i.e., dead-end grunt-work that results in burnout). If you, as a junior developer, want to be re-valued, you need to jump ship.
This creates a feedback loop. Companies view juniors as a cheaper developer you _might_ get 2 years of low-cost work out of (after training) before they'll leave, creating a self fulfilling prophecy.
I've watched (and experienced) this loop multiple times. It's utterly baffling how firms would rather go through the cost and drain of finding and replacing talent rather than re-evaluate and pay their existing, proven talent what they are worth on the open market.
Workers would rather not move around. Workers would rather have a stable position in a job they like, in a community where they can purchase a home and build lives and/or families. Once you get past 35, playing the required musical-chairs needed to advance your career is a real drag. It does not need to be this way.
I'm currently working for a company whose first 4 technical hires (other than the CTO, who wasn't always involved in day-to-day development) were juniors. This was a terrible idea, as there are basic architectural mistakes baked into the codebase all over the place, and lots of issues with data integrity and things that only work most of the time. They'd have been better off with a single senior.
Agree that it makes sense to hire juniors once you've grown though.
Easy, in todays market, there are plenty of experienced developers who are being laid off so you don’t have to hire juniors.
There is no statistic longevity in tech. It’s well known that the quickest method to make more money especially when starting out is to change jobs after two or three years.
Salary compression and inversion is real.
Yes I know it’s a prisoner’s dilemma. If no one is willing to hire juniors, then how do you get a pool of seniors. It’s a local maximization problem
I agree you get better return from seniors, which is why everybody wants to hire seniors. But we get new seniors by training juniors/letting them get experience. I think 5 juniors + 1 senior isn’t the way to do it, you should have at least 1 senior per junior (better still more seniors than juniors). Then you still get stuff done (maybe a bit less than if you didn’t have the juniors) and a few years later you have a couple new useful intermediate developers (and a few years after that they’ll be experienced seniors).
This is very common in Canada and the United States too. We regularly hear companies saying they can't hire good talent, while candidates say they can't find anyone willing to hire people without multiple years of experience. It happens a lot in the trades too, not just software development.
Part of the call to action is to spend the time to hire and train juniors instead of just looking for ready-to-go seniors. It provides the employer with a larger pool of talent at lower cost, an ability to shape their skills and practices early on, and helps the entire industry grow.
The problem with hiring junior developers is risk. They could be junior because of incompetence or wrong attitude opposed to just lacking necessary experience. When hiring a junior you are hedging either competence or experience against expenses and hoping for potential. Potential is the magical ingredient and its hard to recognize before hiring somebody, which is why this is risky.
Conversely hiring really good seniors saves the company money even if a good senior is really expensive. A good senior can probably do the work of 4 junior developers while also introducing code that demands less maintenance into the future, which pay dividends over time.
What I see from some juniors who spoil it for everybody else is immaturity and unrealistic expectations. A hiring company is there to provide you compensation for work. They aren't there to satisfy some emotional fantasy or other self-serving justification.
Because there is greater risk in hiring juniors demand for juniors is lower and there are more juniors competing for those fewer positions.
---
With all of that said above, the goal isn't to get a better junior job, but rather become a senior. Here is how I did it.
First of all I didn't want to be a developer. Travelocity couldn't hire competent front-end developers. It's like they didn't exist. The company saw potential in me and involuntarily relocated me into a developer position. If I wanted to stay employed I had to figure it out. I sucked really bad a first and felt like I was struggling in a vacuum.
After about a year of this my military job needed me to perform security assessments in Afghanistan. You have a tremendous amount of available time on military deployments. Just before deploying I started a personal project, which I continue to work on today nearly a decade later. This little code beautification project kept me busy and it forced me into deep learning of complex algorithms.
When you are deployed in a combat zone you have to be self-sufficient. You don't often have internet. At the time I was writing code on a small netbook with 16gb total storage, because it was durable and portable. I didn't carry around a bunch of unnecessary tooling. You simply learn to do more with less.
Once I got back to Travelocity I discovered I had surpassed some of my peers in problem solving and code proficiency. I was coding all the time even when I didn't have to. I had found every little bit of proficiency I had gained in personal practice allowed me to work faster which then allowed me to become that much more proficient like an accelerating force.
The primary distinguishing factor between seniors and juniors to me is self-sufficiency, predictability, and simplicity. I find juniors tend to spend most of their time living in frameworks, dependency nonsense, tooling, and configurations. These external things distract from predictability and simplicity. They certainly don't benefit self-sufficiency.
I have seen the "we don't want to waste time teaching people. So, hire only senior developers" scenario play out at couple of my previous employers. And, it doesn't end well.
Senior devs have expectations around salary, growth and work. Over time when the company starts running out of steam - funding, growth or even interesting work it gets difficult to keep the senior devs happy.
Once that scenario plays out, companies start scrambling to find interns or junior devs and find out, not many are not interested in working for them because they heard "rumors" about company's hard-ass culture on "not learning on the job".
Slowly, company realize that a team made of only senior devs is too costly for the value they provide. And company starts to cut down, put in hiring freeze telling the senior devs to produce more per person. Some even go to the extent of firing some seniors and getting junior devs and then allowing people to learn on the job.
I'm a senior dev but I'm in a position where I happen to know a few junior devs through my gaming hobby, after talking with them it seems like they're having a hard time.
I know my company hasn't hired juniors for over the last year at least, and that seems to be the same at a lot of places. I've been talking with those juniors recently and most of them are having a hard time getting anything.
This is going to make the senior dev situation worse in a few years since there doesn't seem to be any pipeline to make new ones.
We have no issue whatsoever hiring juniors (we hire about as many as mid-levels), but we don't have to settle for someone who doesn't have internships or projects and the openings can be closed in 2 weeks so it seems like nobody is hiring, but actually the bar has risen (and there are plenty of candidates who clear the bar).
I mostly disagree with this article, but not entirely. I do think there's a trend by the bigger companies to look for senior talent, but there are plenty of firms that rely on one or two senior devs with a team of junior/mid-level devs and I'd say most smaller companies still hire and train junior developers. I'm in the Chicago area and it's possibly unique in its diverse market of employers and thus able to support all manner of dev team make-up.
I'd also say that many junior devs are offshore and are given test and support tasks, and this is especially true in larger corporations.
Lack of enough humans to be senior devs, with many companies having tons of vacancies. They're saying that you need an influx of working juniors who become seniors, but if everyone is only hiring seniors...
This mindset is what leads to utterly incapable people being hired as seniors. If nobody is willing to hire junior or medior developers, then naturally everyone starts calling themselves senior.
Yeah, that's exactly the reason why junior positions in my niche are almost non-existent. Everybody wants to have seniors or at least regulars, but a junior just means problems for everyone. And you can't be sure they will stay once they learn enough.
reply