49

What are the reasons IT companies hire juniors at all, and what companies expect from junior team members?

I'm a student about to start looking for employment in the field of web development, trying to understand better what is expected of me in the first place, and what would be the motives of my potential employer.

  • Is it cheap workforce for mundane tasks?
  • Is it that companies expect to keep you around for longer and benefit from your growth?
7
  • 18
    This varies from locale to locale, so it might help if you give at least a country – Kilisi May 28 at 9:38
  • 24
    How do seniors come about if they werent once a junior ? Gotta start somewhere - are their salaries less then seniors - of course. But when they become seniors their pay also gets adjusted. You do it when you cannot afford a senior but plan to mold or grow that junior into a senior (that takes time). – JonH May 28 at 17:35
  • 1
    It's worth noting that the pool of experienced developers at some time t is a subset of the pool of junior developers at time t-1. In other words, if nobody hires junior developers now there won't be any experienced developers at all a few decades from now. – Erwan May 29 at 18:38
  • 11
    There is also the concept of learning by teaching. Existing developers may become better through the process of working with and sometimes teaching newer developers. IT isn't ditch-digging; in the best cases, knowledge workers can multiply each other's productivity. – Paul D. Waite May 30 at 14:15
  • 2
    One extra point of view is that there are a lot of junior-suited tasks, and with a senior-only team, seniors will get burned out on them (while juniors might often gain valuable experience doing them). – Tomáš Kafka May 31 at 9:29

12 Answers 12

71

Is it cheap workforce for mundane tasks?

Yes - most companies will have a certain amount of relatively "mundane" tasks, (and by that I mean tasks that don't require the higher levels of skill and experience of a senior) that are perfect for juniors, but uneconomical to assign to more senior (and expensive) personnel, but are necessary nonetheless. Companies need these things doing for a suitable price and juniors need jobs, it's a mutually beneficial arrangement.

Is it that companies expect to keep you around for longer and benefit from your growth?

Yes - although this is diminishing in the modern era where people in many fields don't stay in roles for extended times. Even so, there are still environments that can benefit from being able to train a staff that works in the company's preferred way, even if this isn't for an extended stay. The flip side can also drive junior recruitment - remembering the need for mundane tasks mentioned above, it's common for juniors to be hired to fulfill a "junior" role only to move on as they progress, the company doesn't want to pay them senior rates to do junior work and so they now have a need for a new junior.

10
  • 19
    A good company will be hiring people they at least hope will stay around and become senior developers. – DJClayworth May 28 at 8:49
  • 3
    @DJClayworth indeed.. or more specifically hope that enough stick around to become senior and replace existing seniors that leave/retire. – motosubatsu May 28 at 8:55
  • 14
    a good company will be a place that makes it attractive for growing developers to stay. if you can make 30% or more by switching after 2 years, it's hard to stay. if the the difference were low or nonexistant more people would stay. also, some companies make people stuck in the junior role forever, so if people want to actually grow they have to switch... and many more reasons... – Benjamin May 28 at 9:08
  • 2
    I actually find this answer super useful, not only for IT fields but generally speaking. – Clockwork May 28 at 10:50
  • 14
    I basically agree, except that "mundane" seems not quite the right word. As a senior, an awful lot of tasks I do are still rather mundane, sadly. And truly mundane tasks aren't done by developers at all. Perhaps "simpler" would be a better word. – B. Ithica May 28 at 14:29
33

Everyone has already stated valid answers, here is something that was left out; junior mills. A "Junior Mill" is a corporation that has a few senior managers/leads, but everyone else is a junior they keep on for a year or two until they become too expensive. This means that these juniors are often tasked with assignments above their pay grade/level of expertise. It also happens that after the 1st year they get offered a worse contract that they had - lower pay for fewer months on the contract - in hopes they are too inexperienced to stand up for themselves properly.

6
  • 1
    interesting concept – Kilisi May 28 at 9:37
  • 8
    @Kilisi unfortunately, no. My first employer was a junior mill; after the first contracted had expired and therefore automatically renewed (as by the laws of my country), they offered me a new contract for less time and less money, which I of course declined. Then they offered me a slight raise, but still just a half year contract not a year contract. I declined again, HR tried to bully me into submission (I know my rights), but found myself a new job asap anyways. – Lucas May 28 at 14:26
  • With such short term goals, the result may be huge technical debt due to copy-paste reuse. – Peter Mortensen May 28 at 20:47
  • 3
    This has a very high overlap with the "body shop". – chrylis -cautiouslyoptimistic- May 28 at 22:49
  • 3
    @PeterMortensen sure, but at that point you just throw the new round of juniors at the same problem. No need to worry about tech data and lava code when your product works and managers have good numbers to show. It's a... bad way to code... and as someone who tries to make code performant, readable, extendable, etc it pains me to say that there are times and places where those things are less important than keeping bills low and deliverables delivered. – WernerCD May 29 at 22:49
31

Why do companies hire junior software developers?

It's not like they have much of a choice. They either need to coax experienced developers away from other companies or grow their own.

  • According to Robert Martin "Uncle Bob", author of Clean Code, the number of software developers doubles every 5 years. Here is a 6+ hours playlist of him on YouTube.

In addition to that:

  • Senior software developers are mortal. They die. They retire. They need to be replaced.
  • And out of those that haven't died yet and haven't retired yet, many get promoted into management positions, to help lead or train the newer generations of developers.
  • The term "software developer" is also a moving target. Although many fundamentals remain the same, the field and the tech stacks are constantly changing. Many software developers are life-long learners, but just as many are not, and some become unqualified to do the work or simply decide to leave the field entirely.
  • Many junior developers are also willing to work long hours or work outside of work hours to keep up with new technologies, but as developers get older and more experienced, and as they may get a life outside of work, their priorities can shift away from it.

Again, since there are not enough experienced developers, or more precisely not enough qualified experienced developers, to go around, this leaves a vacuum of work for junior developers to try to fill in. There is actually a ton of churn in the industry. It's also a possibility that many junior positions, in the less selective companies, become open simply because the previous junior developer who held the position couldn't do the job to the satisfaction of their employer.

And now, I'll try to answer a question you haven't asked but maybe thinking about. If companies really hire "junior developers" and if there is so much churn, why is it so hard to find advertised "junior developer" positions?

That's because many people want to become junior developers, and companies get flooded with job applications, whether they advertise for those junior positions, or not. And it's expensive to screen all of those applicants.

So the bulk of the hiring of juniors gets done through the "hidden job market". If you don't know what that is yet, please google it. This answer has veered enough off-track already.

I'm a student about to start looking for employment in the field of web development, trying to understand better what is expected of me in the first place

This part of your question is actually very difficult to answer. "Web development" is a very wide field.

Web development at a Big Tech company like Google is going to be very different than web development at a small mom-and-pop online shop with only two or three employees.

2
  • @Stephan Branczyk, I was just wondering about 1 thing : Is it true that to be promoted to "Software Architect", one should be a very good software developer first ? – Job_September_2020 May 28 at 14:47
  • 2
    @Job_September_2020, In theory, yes. In practice, not necessarily. Many companies only look at the number of years of experience, plus which company you previously worked at, which both are horrible ways to make such a decision in my personal opinion. – Stephan Branczyk May 28 at 15:13
20

Is it cheap workforce for mundane tasks?

Interestingly, I disagree with most other answers about juniors being cheap workforces. But my answer will apply especially to software developers.

Straight to the point: I don't think juniors are cheaper than seniors. The delta between junior and senior wages differs a lot based on location. Where I live (central Europe), the difference between what you described as junior (fresh our of university) versus a senior (multiple years of work experience) is not like 3x or more. From my experience, we talk about 30-100% higher wage for mid level and senior employees. (Although university graduates are sometimes already considered mid level when they start their work life, but that just as a side note.)

Having said that, also from my experience, the value a senior brings is significantly higher than this 30-100% difference in pay. Experienced people use different approaches to solve the same tasks, which either save time or money (potentially also in the long run based on quality and documentation). Especially in the software business, this can be seen and measured fairly easily (e.g. one vs. five days for the same or an equal task).

So the relative value of a senior developer is for sure higher than the relative value of a junior. The reasons for employers to consider juniors must be something else. Some examples:

  • If no one hires juniors which allows them to grow, the world at some point will run out of seniors.
  • Some businesses do not have the money for a senior at the point of hiring.
  • Employers expect more loyalty of juniors by giving them a chance to grow, expecting them to stay "forever". (Personally, I don't think this really works)
  • Employers have tasks to solve, for which they cannot find or do not want to spend senior workforce.
  • Other employees (potential seniors) do not want more of their kind in the team, in fear of competition. Seems like the worst case to lose the promotion to the new guy.
  • There is more demand than offer on the market.
4
  • 6
    Also, on top of the pay there is an overhead for each employee which is basically the same for a senior and a junior (laptop, desk, licenses) – Helena May 28 at 20:33
  • 3
    Juniors may also be less grumpy and have smaller egos (though there are of course exceptions). – Peter Mortensen May 28 at 20:42
  • Also, only rather silly companies would hire juniors to just throw them at a problem - instead, you ideally want juniors (ideally, one junior :)) to work rather closely with a senior that's a good mentor, and you can get results more in line with the difference in paygrade. It's still an investment, though - you hope the junior will stay with you as he matures into a senior, and will keep their knowledge of the codebase, understanding of the people around them and the business and all that. Ultimately, you might not be able to get a senior, and well managed juniors are still net plus. – Luaan May 31 at 10:48
  • 1
    There's also many ways to do software development. If you're doing software-on-demand, you can afford more junior teams in general since maintenance issues related to (relatively!) poor code pile up a lot slower than in software you develop for decades. If you're doing "boxed" software (i.e. make once, sell many times), the profit multiplier on each employee is so high that wages aren't really connected to profit much - and the added workload you can do with the juniors outweighs not having a junior (since you can't find enough seniors on the market). – Luaan May 31 at 10:50
13

Availability and cost

The reasons will differ depending on the market but the market for developers is currently very good, so companies don't tend to retain junior staff long enough to benefit from any growth. Exceptions for companies that have a stable stock option ball and chain.

My current company has mostly junior engineers because it can't hire enough seniors to do the work and if they could, I am not sure they would hire more inexperienced people. Same with my last organization, which explicitly didn't want junior employees but had no choice.

6
  • 1
    Indeed. As Matthew explains, typically you just can't find any seasoned, experienced people in the niche at hand. – Fattie May 28 at 11:10
  • Management keeps trying to only hire senior-level for my team, and honestly it's overrated. A lot of the "seniors" turn out to be just terrible anyway, so you might as well take a chance on some juniors, too. A balanced team is best, the juniors can bring fresh energy and the seniors can keep them from accidentally breaking everything. – user3067860 May 28 at 17:42
  • @user3067860 my company has 6 senior jobs open. No seniors currently work here. The entire software development team is two juniors. So sometimes you just cannot get seniors. – Matthew Gaiser May 28 at 17:52
  • @MatthewGaiser You can have half of our seniors (the useless half, haha). But yeah, these stories I hear about all junior workplaces are pretty terrifying, I'm definitely not advocating that!! Just a good mix of junior and senior together. – user3067860 May 28 at 18:37
  • 1
    @MatthewGaiser TBH, when a company says "there aren't any qualified people in this area" mostly what I hear is "there aren't any qualified people who want to work with us for what we want to pay them". – user3067860 Jun 1 at 17:01
9

I hire a lot of very young people, I have a strong preference for that.

Is it cheap workforce for mundane tasks?

No.

Is it that companies expect to keep you around for longer and benefit from your growth?

Hopefully.

The main reason I hire these people is that they have a modern approach to many problems. They will not hesitate to use new technologies and they will use plenty of solutions others may not.

I am old(-ish), so it is not that I think that older people are not useful (we are brilliant after all). It is just that I love to be challenged and the young people will do this without much drama.

There is a drawback, though: finding the very good ones is tough. A lot have zero insight into their knowledge and it requires a lot of coaching (which I like). A healthy balance in ages helps with that too.

Finally, the company must be supportive. The one I work in is and it is wonderful.

1
  • +1 - good perspective! – Theo Tiger May 29 at 23:30
7

IT consultant companies bill by the hour. So often it doesn't matter how experienced you are because the company makes a profit even on juniors.

2
  • 3
    This depends on how the contract is set up. For US federal contracts, you have to justify each individual person's billing rate (based mostly on "years worked", unfortunately, and not any useful metric). This has no relation at all to pay. So it's actually possible for a company to be losing money on a junior, if they really needed more people to get the project done so they offered a competitive wage but the contract won't pay that much for a junior. – user3067860 May 28 at 17:19
  • @user3067860 you're absolutely right. But, I've worked in government and a lot of contracts are set up so bad that IT companies can do this. You have amateurs on the government side and professionals on the IT-company side. The contract is going to be lopsided. (my background: archivist) – Pieter B May 29 at 6:27
6

When a new fresh guy, especially those who just graduate students from university are warm welcomed, because:

  1. Yes, they are cheaper
  2. Some hands-on job need this students finish, like testing.
  3. If you grow up, then that is better, company can earn benefit from your growing and your current salary.
  4. THIS IS THE MOST IMPORTANT: Your thinking mind still keep relative "pure", would more listen to orders from company.
3

What companies expect from junior team members?

It will vary per company, but in my 12 years of experience, nothing is expected of a junior other than a desire to work and learn. - Of course you need to know some of the basics, and you're in competition with other applicants.

Generally (in companies I've worked at) it is expected they will loose the company money for at least the first year, and only start to make money after 3 years. Again this varies largely per company.

What are the reasons IT companies hire juniors at all

  • The company is expanding and juniors are affordable and trainable (seniors can advance their skills by training, as well as the company getting a loyal homegrown employee)
  • Seniors become overloaded with work (easier tasks can be offloaded to a junior)
  • Tasks too easy (and mundane) for a senior is a waste of their skills. They may slack off or leave the company if work isn't exciting. These tasks will be good practice and challenging for a junior. So use the right dev for the job
  • The company is a start-up with no experience and thinks a junior is enough to build them the next Instagram
  • If a company only hires seniors the systems can become too complex with no consideration for juniors learning it. This leaves the company in a vulnerable position when seniors leave, and allows them to demand too much money because they know they can't be replaced
  • Juniors wont be as stubborn to adapt to the companies procedures, so a fresh junior to train is something companies desire
2

Why do they hire juniors? Because they have tasks that need to be done, which the junior can either do or easily be trained to do.

Calling it cheap workforce for mundane tasks, is cheapening everyone involved. Money is involved, sure, paying for experience and abilities that you don’t need is just silly. That doesn’t mean that the tasks can be done by a 5th grader.

There are a lot of tasks that are need to be done, which take skill and time to be done, which none the less, don’t require 20 years of experience.

This reminds me of Apple’s SSL bug, I don’t know how experienced the person that wrote it was, but a good junior could have easily caught it in a code review, or by writing an automated test. Paying such a junior, even at Silicon Valley inflated wages, for a year, would have been well worth the cost for ONE bug.

0

IMHO, it a filter

To see who have potential to what.

Everyone starts on small easy tasks, and the way these task are done (time , code quality, interesting implementation) juniors are judged.

Would not be surprised, if occasionally, on personal basis, junior will receive a more complex task, research one, learning one etc

Based on these criteria, company will / may decide to invest in the junior developer advancement - harder assignments, higher level of responsibility, perhaps a course in the specific technology that company works with. This is the stage where loyalty checked

Depends, of course on company style and policy. More and more companies these days understand that it is easier to develop a talent in-house than purchasing already made one.

But there are still some that have short term / continuous need in monotonic maintenance / development tasks that need to be done on regular basis and not financially viable for senior to do.

In both these cases, as a junior dev you get a real world experience

0

Alternate take as someone who's hiring students/interns/juniors:

The angle of getting someone to do cheap labor or "the grunt work" never sat well with me for a couple of reasons:

  • The student probably only really just now comprehends what javac is, and
  • The grunt work is going to burn them out of this position or role faster than any of the other horror stories could.

So I want to balance it out for them; give them a chance to work with someone on real, definitive problems that have upstream implications and can be presented to stakeholders, while keeping them largely insulated from the burden of having to do it all on their own.

To this point,

Is it that companies expect to keep you around for longer and benefit from your growth?

The average amount of time for someone in the IT field - at least software development - is about two years. A breakdown of that would look like:

  • The first six months are spent on getting you in context and warmed up to everything that we're doing and how we're doing it. Usually a make-or-break time frame.
  • The next 12 months are spent getting you more in rhythm with bigger and bigger efforts as well as taking on an active role in some things (likely towards the end of that 12 month period).
  • The last 6 months are spent on building up your confidence and seeing if you have the appetite to continue on with us, based on pay grade, performance and your own personal goals.

There would of course be review cycles and pay raises in that period, depending on how well they're doing.

Ultimately a software company does good to keep and retain the juniors they train, as they'll be more up to speed with the domain than someone freshly hired, but it's always a risk. The junior may want to leave, or the work may not be that rewarding, or there's some aspect of it that is otherwise unsatisfactory that would want them to depart, and it's a responsibility of the lead developer(s) to help prepare them for those scenarios.

We're not just training juniors up to work with us; we're training them to work well wherever they land. (This has a tendency to pay dividends with regards to networking.)

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .