To say that the US market for software engineers has been broken is something of an understatement. For junior and entry-level engineers, the competition for jobs is intense and miserable -- but many who break through have the strange experience of transitioning from constantly-shunned to perpetually hounded by recruiters in the span of about 2-3 years (hiya Amazon recruiters!). But many would-be entry-level engineers have few opportunities to build the experience that makes them hirable: a classic catch-22.

To try to roughly quantify how bad this is, I looked briefly at a sample of several dozen job postings for entry level software engineers (e.g., no prior professional experience required) on LinkedIn over 24 hours and found the following:

• Average applications per job posting: 556
• Average applications per week, per job posting: 439
• Average applications per week, per job posting (role is explicitly full remote): 840
• Average applications per week, per job posting (company is a household name): 1,228

These are pretty ridiculous odds - and there's a lot of anecdotal evidence that LinkedIn is uniquely bad - a death spiral of high volume spammy applications AND low quality job postings that never actually result in interviews. But the point remains.

To get a sense of how dire this actually looks from a candidate's perspective, I talked to some people in my network + some people online to collect a few dozen data points from recent grads and boot campers. Here's what the average funnel looks like across all the anecdotes I collected:

• Applications: 171
• Interviews: 3
• Offers: 1

I double checked these numbers because of how ridiculous they were. And this was a group that was heavily tilted towards those graduating with a CS degree, not majority boot campers. For comparison, I applied to 4 firms out of college and got 3 offers before withdrawing from the 4th interview, and many people in my social circles did similar single-digit-numbers of applications. It seems things have gotten much worse since then!

Reddit threads echo with cries of "Why don't companies want to invest in training anymore?" This is a great question. Let's dig in.

The typical calculus for an employer that needs to hire goes like this:

1. Spend a bunch of money recruiting and hiring a new employee.
2. Spend months (or years) training this employee to be productive and begin generating more value for the business than they cost.
3. Eventually this employee will generate enough value that it pays back the cost of the expensive things you did in step 1 and 2.
4. Hope they don't leave before that, because if they do you have to start over from step 1, and you're worse off than before you started.
5. If this happens often enough you go bankrupt. Worse, people might make fun of you on TechCrunch.

It gets worse though.

At current market salaries and ramp up times, entry-level software engineers are probably the most expensive employees with simultaneously the longest time-to-productivity at a company, and on average the industry thinks this takes -- working backwards from revealed preference -- on the order of 1-2 years. During that time, their value to the organization is often considered at best a wash [1] - reflecting more future potential than current capability. And so I don't think its unusual for hiring managers to visualize the ROI of hiring engineers like this:

Of course, this is a highly stylized hypothetical - many competent entry-level engineers become super productive very quickly, and I'm guessing most firms plan to recoup their investment in junior engineers in far less time than the ~2.5 years it takes in this example. But this graph doesn't have to reflect reality so much as broadly suggest - in a very directional way - a belief in a particular probability distribution. If we're arguing about WHERE the blue line crosses 0, then we have already conceded an important point:

If I'm hiring, it's better business if someone else trains junior engineers and then I hire them away.

Many firms act like this is true and mostly hire only experienced engineers. Because that's what's rational if they broadly buy into this theory of ROI.

The final piece of the puzzle is the "changing nature of work." Employees job hop much more often now than they used to; they are effectively incentivized to do so because new jobs usually come with big raises (and I guess it is perfectly rational because companies can usually outbid current employers by virtue of not having paid any of their prior training costs). Software engineers have an average tenure of about 2 years; employers expect this, it is a known thing. So they conclude that years-long training and development investments don't make sense. It's all just a big repeated game of prisoner's dilemma but with a different collaborator each iteration: the best move is to defect, because defecting is the industry norm.

Solutions

TL;DR: I think we broadly need a better way to shorten payback periods and de-risk onramps into the industry so companies are willing to create those entry level roles; the existing solutions either have serious drawbacks or haven't solved the problem effectively:

Lowering entry level salaries

One intuitive reaction I had is that junior engineer salaries need to go down for the classic econ 101 reason that there are clearly far more unemployed entry-level engineers than there are jobs for them, and current salaries are very attractive, with lots of people who will happily work for way less than the prevailing wage.

Entry level software engineer base salaries
Bottom 10%	$59k
Median	$78k
Top 10%	$112k

Theoretically, this change would fix some of the supply imbalance: some aspiring engineers would decide to become real estate agents instead, and some firms would decide they can make the math work on a junior engineer at $55k (but not $85k). Unfortunately, entry-level salaries have in fact gone up over time...probably due to some combination of:

• FAANG: Top US tech companies have incredible leverage, and can make A LOT more money from incremental engineering hires, including entry level, than most other companies [2]. Many of them run college recruiting programs precisely because they're so uncommonly profitable at scale that small optimizations result in big gains; their payback period on entry level engineers is shorter than average and their time horizons are much longer so the urgency to make sure every hire is productive ASAP isn't as high. Also, there's a small subset of people who basically never leave their jobs, so by definition you have to compete for entry-level employees if you want a chance at those people. This pushes salaries up, since FAANG can comfortably afford to scoop up the top 10% of every cohort and shift the entire demand curve.
• The Alchian-Allen effect: Hiring is so expensive in general for most firms that if there's budget to hire at all, it might as well be an experienced engineer, because the productivity difference is really high, but the difference in total cost between a senior and junior hire can be surprisingly low given high fixed overhead (health insurance, hardware, software, office space, management, benefits, taxes, etc. are expensive + don't vary much by experience level of the hire). Because of this, its not uncommon at many firms to budget using headcount, and if headcount is your limiting factor, you aren't going to "waste" it on junior hires.
• Cross-elasticity of demand: Demand is so high that not everyone can meet their hiring quotas for senior engineers; this generous budget is redirected downward as firms "settle" for hiring more junior engineers than they ideally wanted. This pushes junior salaries up.

So salaries stay really high. And any individual firm that offers lower salaries drives away the best applicants, and has to sift through a candidate pool with low signal to noise ratio. Also, I forgot to mention this industry sucks at identifying and selecting talent in interviews, so there's no good way for most firms to cost-effectively assess whether a candidate with 6 years of experience is worth $105k or $450k total comp, nevermind entry level applicants with no work history. So we are probably stuck in this weird spot until some of the above things change.

Create better materials for self-teaching

Self-taught engineers are not unheard of, and all the materials to become a competent software engineer are technically online for free to anyone who cares to look, but we haven't reached a point yet where most people can legitimately break into the industry from self-learning. Without a credential of any sort, its just too hard to stand out from the (very large) crowd. And again, software interviews are so bad that its a running joke in the industry, and salaries are so high that most companies can't afford to interview every random who walks in off the street claiming to know Java without any credentials or formal training (remember: engineers are interviewed primarily by more senior engineers and engineering managers, so discovery costs are extremely high). So credential gating persists; self-teaching isn't so much the problem as motivating students and creating cost effective ways for prospects to demonstrate skills and competencies.

Fix college education

College degrees are expensive and time-consuming to obtain, and the recent economic pullback is suggesting the market can't even absorb all the current CS graduates. CS degrees (by design) just don't teach a lot of skills professional software engineers need to be productive right away, so I doubt there's much room for dramatic improvement here in the short term. Also, lol

Coding boot camps (students pay tuition)

In contrast, coding boot camps were a neat idea with limited initial success, but they rapidly ran through the entire adult population of "has English degree and would be a decent engineer at Google, but currently handling accounts receivables at a restaurant chain due to happenstance." The average person can't learn all the theory, practical skills, and instincts in 12 weeks with no prior background or interest. You just can't. Not in a repeatable way. Also, tuition costs on the order of like...$15 grand or more. There's some innovation here, with income-share-agreements and nonprofits jumping in, but on balance they're making the junior engineer problem worse, not better, by churning out job seekers with few skills and high expectations.

Industry boot camps (company pays nominal salary)

Wayfair and a few other companies had interesting experiments with a salary-paying training program geared towards boot camp grads: It was called Wayfair Labs, and my understanding is they used the program to both train boot campers in engineering skills, and also selected the most promising graduates for full time offers. I suspect these programs aren't sustainable and don't scale because they just aren't that attractive to the boot camp grads: the best engineers don't want to spend 3 months training full time to have a shot at an offer from a single company when they can just…keep interviewing with a lot of companies simultaneously on a rolling basis and skip right to the make-a-lot-of-money part. And if you aren't hired at the end of the program, it's actually perceived as a black mark in a "If even Wayfair didn't hire you after so much training, then why should I?" sort of way.

Basically, industry boot camps create an adverse selection problem over time (Wayfair only gets the boot camp grads who couldn't directly get a full time permanent offer anywhere) as well as a signaling problem (those who join the program run the risk of making their resume look worse than if they hadn't attended, if they fail to get or accept an offer from Wayfair at the end).

Internships

Internships seem to be moderately effective, and are correlated with successful outcomes (and often 1 order of magnitude fewer applications to land a job, based on the data I collected), but these are generally only available to college students, and the peculiarities of US higher ed makes this difficult to adapt outside of university programs -- the biggest benefit is that internships end due to the student's unambiguous obligation to return to school, and this provides plausible deniability that it wasn't due to unsatisfactory performance leading to inability to convert to a full time position. Again, this avoids a signaling problem when the candidate applies to full time jobs.

The side door

My current best idea so far for how to fix some of this is to formalize career ladders into software engineering from tangential disciplines like "Solutions Engineer" and "Technical Support Escalation Representative." It's not a pure win because it'd be a hassle for those departments to keep having to replace folks, but these roles are natural onramps because they often involve scripting or coding of some kind, interact regularly with the real engineering team, and crucially, provide a huge amount of context, relationships, and product knowledge that shortens the onboarding period when they transition to engineering. More companies should try this!

I hope more candidates consider this route. I hope more companies build these sorts of opportunities into their organizations. I dunno. Otherwise we are squandering an opportunity to grow our field.

[1] Many people have pointed out to me that this is partly because junior developers suck up a lot of bandwidth from senior engineers/managers for coaching and mentorship - to emphasize: I heard a lot of "hiring junior engineers makes teams slower, not faster." And thus it additionally makes sense why larger companies are more amenable to junior engineers than startups: startups want to move fast.
[2] There's a lot of evidence that this is true: most other countries think top US tech salaries are shockingly, outrageously high, but that's because they don't have as many hugely profitable tech companies competing for talent (yet), although the arbitrage is closing in recent years.