The Problem
In January 2025, Handshake released its internship index for that month. Technology internship postings had fallen 30 percent since January 2023. Across the same window, entry-level hiring at the 15 largest tech firms dropped 25 percent. These are not marginal shifts. They describe a labor market where the historical on-ramp — the internship, the junior role, the three-year apprenticeship in code that converts raw ability into useful knowledge — is contracting faster than the broader economy.
The immediate effect is obvious: fewer entry points. But the secondary effect is what matters for a developer trying to build a sustainable career outside the elite tier. The market is not replacing junior developers with AI. It is eliminating the hiring category entirely while raising the implicit skill floor for "first job" from 0-to-1 to 1-to-3. A bootcamp graduate in 2025 faces a different labor market than one in 2019 — not because the work is harder, but because the on-ramp is gone and the bar for entry has moved.
This creates a genuine structural problem: how do developers build the domain knowledge and tacit skill that used to come from years inside a company when companies have stopped hiring the people years-in-company would have trained? The answer developers are finding is that they don't — at least not through the same channel. And understanding what they are building instead, and why it works for some and fails for others, is essential for anyone outside the elite networks trying to capture value in a market where junior roles are disappearing.
Why This Is Happening
Three structural forces are colliding. The first is straightforward: AI has made the execution component of junior work — the kind of task you assign to someone with three months of ramp-up to teach them the codebase while producing incremental value — automatable. A junior developer's value proposition to a firm has always been dual: produce real code and progress, while learning the domain and absorbing institutional knowledge. The latter is still valuable. The former is becoming optional. This alone does not eliminate junior hiring, but it removes half the economic justification.
The second force is hiring bar creep. Firms are optimizing for reduced onboarding cost at the moment when onboarding AI-assisted junior work is expensive and uncertain. If you can hire a mid-level developer at a 20 percent premium and get higher confidence in output, the math changes. Entry-level hiring becomes a discounted training investment, and investment in training depreciates when the trainee can be replaced by a model. Companies are rebalancing: hire fewer juniors, higher bar for who qualifies as junior, and demand that junior hires come in with domain knowledge they should have been learning on the job.
The third is a coordination failure at the supply side. Bootcamps and degree programs have continued to produce graduates at scale — Course Report 2025 data shows bootcamp graduates averaging a first-job salary of $61,836, consistent with the historical $56–$70K range — but the employers who have historically hired them are not. The gap between "there are 60,000+ bootcamp graduates per year" and "entry-level positions declined 30 percent at firms that used to hire them" is not about supply quality. It is about demand destruction that has no mechanical replacement.
What has been tried and fallen short: apprenticeship programs like Apprenti (now operating federal registered apprenticeships with Amazon and Microsoft) exist, but at scale they are tiny compared to the hiring collapse. Outreachy and Google Summer of Code place highly selected cohorts, but together they account for a few thousand placements annually — meaningful for individuals, invisible at the market level. Bootcamp employment rates remain high on paper — Course Report 2025 reports 79 percent placement within 180 days — but the actual problem is not employment rate, it is wage floor and career trajectory. A bootcamp graduate placing into a $61K first role with no domain knowledge and no company-run training pipeline is not on the same trajectory as a bootcamp graduate in 2018 placing into a $65K role at a firm with a documented two-year junior track.
The coordination failure is explicit: the people producing junior developers have no control over the demand side, and the demand side has no incentive to signal what they actually want because they have fewer junior roles to offer. Bootcamps respond by teaching more AI tools and emphasizing portfolio projects, which narrows the gap at the execution layer but does nothing to address the domain knowledge problem — the thing that used to be learned inside a company.
What Developers Are Actually Doing
The response from developers outside the elite networks has been pragmatic and bifurcating. One path is premature specialization: focus on a specific domain early, build public work in that domain, and try to convert that visibility into a domain-adjacent role that skips the undifferentiated junior phase. A developer who spends eighteen months building cryptocurrency or ML infrastructure tools, documenting it carefully, and gaining visibility in those communities can sometimes land an interview at a firm working in that domain. They are not hired as a junior. They are hired as someone who already knows the terrain. The downside is obvious: if you specialize early and the domain contracts or you lose interest, you are now competing against juniors in other domains with the overhead of retraining.
The second path is portfolio substitution for company training. Without the company providing domain knowledge, developers are outsourcing that learning to open-source contribution, writing, and personal projects. This works, but it is asymmetric. A developer who has contributed to a significant open-source project for six months has learned more than most junior roles would teach in a year. But only developers with sufficient financial runway to work unpaid for six months can actually execute this strategy. For everyone else, the bootstrap cost is real.
A third path is deferring specialization and chasing breadth — staying generalist longer, building in public across multiple domains, and trying to land roles that value adaptability. This is lower-risk in some ways (you are not hostage to one domain contracting) but it makes you less legible as a junior specialist. Firms looking for a junior who knows Kotlin or Elixir or machine learning infrastructure will not hire the person who knows a little Kotlin and more JavaScript, even if that person's actual learning speed is higher.
The pattern across all three is the same: developers are absorbing the cost and responsibility that used to be distributed between themselves and employers. Instead of a bootcamp teaching you to code and a company teaching you the domain, you are expected to do both before you arrive at the company. The firms are not paying for that education. The bootcamps cannot deliver it. So developers are self-funding it — by working unpaid on open-source, by documenting learning to build portfolio signals, by speculating on early specialization. Some of this produces real skill. Much of it produces credential accumulation with marginal skill transfer.
The Build Opportunity
The genuine gap here is not another bootcamp or another online course. It is coordinated domain apprenticeship that exists outside the firm — structured learning that is specific enough to deliver real tacit knowledge (not generic coding skills), runs fast enough to not require unpaid labor for a year, and is legible enough to employers that a developer who completes it is actually hirable. This requires solving several hard problems simultaneously.
The first is curriculum design under constraint. A domain apprenticeship cannot teach someone to be a junior at a specific firm because firms are heterogeneous and do not coordinate. It also cannot teach "what every developer should know" because that is too broad. What it can teach is the production pattern in a domain — the specific texture of problems, the canonical stack, the coordination dynamics, the failure modes. For something like machine learning infrastructure or backend payments systems or mobile app distribution, that is a specific, bounded set of knowledge. The hard part is doing it fast and with real outputs, not fake projects.
The second is creating output that is both meaningful and legal. You could run an intensive apprenticeship where developers contribute to production open-source projects in a structured way over six weeks or three months. That gives them real output to point to and real knowledge gained. But the legal and coordination burden of running an apprenticeship with meaningful production output — liability, intellectual property clarity, community norms around unpaid work — is high. The easier path is teaching the domain by having them build production-quality projects on their own stack, but then you need to solve the distribution and visibility problem: how does a solo developer's three-month project get in front of employers in that domain?
The third is reducing capital requirements without eliminating quality gates. An intensive in-person apprenticeship solves the social and pacing problem but requires geographic concentration and upfront cost. A fully asynchronous apprenticeship is cheaper but has higher dropout rates and lower learning velocity. A hybrid model with structured cohorts, async materials, and periodic synchronous work might be the middle ground, but it is harder to run and more expensive than pure-play online courses.
What exists to build on: Open-source communities already run some version of this (Linux kernel learning paths, Kubernetes contributor development, machine learning frameworks). The mechanics are there. What is missing is the explicit apprenticeship framing — the curriculum design, the cohort structure, the employer signaling, the financial model. This is not a technology problem, it is a coordination and pedagogy problem.
A concrete project brief: build a structured domain apprenticeship for one specific, high-demand domain (machine learning infrastructure, or backend systems, or security tooling — something with a bounded but substantial body of knowledge and real employer demand). Run a 12-week cohort model. Have participants contribute to real open-source projects in that domain as the core output. Charge participants or secure employer sponsorship. Place the graduates. Measure and iterate on hiring velocity. The hard part is not the technology. It is scaling the human logistics and maintaining quality gates. But if this works for one domain at one cohort size, the model is proof and replicable.
A second opportunity is employer coordination around signaling. There is no central mechanism that lets employers pre-commit to hiring criteria for domain apprenticeship graduates. If five major firms said "we will interview graduates of the Kubernetes internship who completed these projects," the apprenticeship becomes instantly more valuable because it is legible. This is not expensive. It is coordination. It requires someone willing to do the coordination work — talking to employers, building the standard, evolving it. This is not a build play. It is an organization play. But it is a prerequisite to scaling apprenticeships beyond hobby projects.