A deep dive into why massive firings happen in software, how post-COVID overhiring and interest rates reshaped hiring, what the data actually shows, and what future developers should do next.
The short version: layoffs are real, but “no more opportunities” isn’t
Mass layoffs in software feel like a contradiction. We keep hearing that “software is eating the world,” yet big-name companies cut thousands of roles at once. The reality is that layoffs are often less about software becoming unnecessary and more about how modern tech companies finance growth, how headcount is used as a scaling lever, and how quickly demand and capital conditions can flip.
Post-COVID, many firms hired as if the 2020–2021 demand spike and near-zero interest rates would last indefinitely. Then inflation surged, central banks raised rates, cloud spend rationalized, e-commerce normalized, and venture funding cooled. Companies corrected budgets—sometimes brutally—because payroll is the biggest controllable cost.
The most important question for future developers is not whether layoffs happened (they did), but what the underlying demand curve for software work looks like, and which types of roles are expanding versus contracting.
This article breaks down what actually happens during “mass firings,” why they cluster, what the data says, and what a realistic path looks like for new and future developers.
What “mass firings” in software actually are (and aren’t)
Layoffs are not the same as “software jobs disappearing”
When headlines announce layoffs at large tech firms, the implication is often that software engineering demand collapsed. But layoffs frequently reflect:
- Budget rebalancing (shift spend from experiments to profitable core)
- Reversal of aggressive growth assumptions
- Cost of capital change (rates, funding conditions)
- Org design resets (management layers, duplicated teams after acquisitions)
- Strategy changes (consumer bets trimmed, enterprise focus increased)
- Geography and wage arbitrage (more distributed hiring, fewer high-cost hubs)
Layoffs do not necessarily mean fewer software jobs overall. They often mean fewer jobs at a specific class of company (e.g., ad-driven consumer platforms) and more jobs elsewhere (healthcare, industrial, defense, energy, fintech, logistics, government).
Why layoffs cluster and feel contagious
You’ll notice layoffs happen in waves. That’s not coincidence—it’s incentive alignment:
- When one major company cuts headcount, others gain “cover” to do the same without being singled out.
- Public companies respond to investor expectations; “operational efficiency” becomes a narrative.
- Hiring freezes spread, and fewer job switches create the impression that the whole market is shut.
This is partly why layoffs can feel like a sector collapse, even though it’s frequently a capital cycle plus demand normalization.
The post-COVID overhiring story: what changed, exactly?
1) Demand shock: digital adoption spiked in 2020–2021
During lockdowns, demand jumped for:
- E-commerce and delivery
- Streaming and gaming
- Collaboration tools
- Cloud infrastructure
- Online payments
- Cybersecurity
- Remote work tooling
Many companies interpreted this spike as a permanent step-change and staffed accordingly.
Evidence (digital behavior and economic shifts):
- U.S. Census e-commerce statistics show the COVID-era jump and subsequent normalization in e-commerce share growth rates.
https://www.census.gov/retail/index.html
2) Capital was cheap, so growth-at-all-costs made sense (temporarily)
In a low-rate world, future earnings are valued more highly; investors reward growth. That rewards:
- aggressive hiring
- aggressive customer acquisition
- aggressive experimentation
When rates rise, the math flips: near-term profitability becomes more valuable.
Evidence (rate hikes / monetary policy):
- Federal Reserve policy decisions and rate history (FOMC).
https://www.federalreserve.gov/monetarypolicy/fomc.htm - FRED data for the federal funds rate (long-run chart).
https://fred.stlouisfed.org/series/FEDFUNDS
3) Overhiring wasn’t just “too many engineers”—it was organizational scaling
Overhiring often includes:
- recruiting orgs built for hypergrowth
- layers of management
- programs and operations roles
- duplicated product lines
- teams attached to speculative initiatives
Many layoffs that looked like “engineering cuts” were also org structure resets.
4) The reversal: normalization + rates + cost discipline
As usage normalized and growth slowed, companies had payroll sized for a different world. If revenue growth drops from, say, 30–50% to single digits, headcount growth must stop and sometimes reverse.
What happens inside a company during a major layoff (the mechanics)
Layoffs are usually a sequence, not a single event:
Phase 1: Hiring freeze and “backfill approvals”
Before layoffs, you often see:
- open roles paused
- “critical only” hiring
- managers required to justify replacements
- projects forced to show ROI
Phase 2: Headcount targets and reorg design
Leadership sets a target like “reduce operating expenses by X%.” Then finance and HR translate that into headcount reductions by org. Common outcomes:
- whole product lines shut down
- “platform consolidation”
- management layer removal
- geographic shifts
Phase 3: Selection criteria (how roles get cut)
Contrary to popular belief, it’s not always “bottom performers.” Selection may be based on:
- project cancellation (even if the team is strong)
- redundant roles across teams
- location/legal constraints
- compensation bands (expensive roles are a bigger lever)
- manager influence and organizational politics
Phase 4: Aftermath: productivity dip, then stabilization
Short-term consequences:
- loss of institutional knowledge
- incident risk as on-call rotations change
- morale and voluntary attrition
- delayed roadmaps
Medium-term:
- simpler org structure
- narrower scope
- more focus on reliability and cost efficiency
This is why it can feel like the industry is chaotic: layoffs aren’t just headcount events; they’re architecture and strategy events.
Is the software job market actually shrinking? What the data suggests
A key mistake is using layoffs at famous tech companies as a proxy for the entire software labor market. Many developers don’t work at “Big Tech”; they work in non-tech industries doing software.
Use broad labor market data, not headlines
For U.S.-centric readers, the Bureau of Labor Statistics (BLS) is the best baseline for occupational outlooks, even though any forecast has uncertainty.
Evidence (employment outlook):
- BLS Occupational Outlook Handbook (Software Developers).
https://www.bls.gov/ooh/computer-and-information-technology/software-developers.htm
BLS projections are not a guarantee, but they’re a stronger signal than social media sentiment. They also reflect the fact that software is embedded into most sectors.
Job openings and hiring are cyclical
A high-interest-rate environment tends to slow hiring in risk-funded segments. To track this:
- JOLTS (Job Openings and Labor Turnover Survey) gives a macro view of openings and quits.
https://www.bls.gov/jlt/
It won’t isolate “software developers” perfectly, but it helps separate “market is dead” narratives from actual labor market movement.
Why it feels worse for entry-level developers (even if demand exists)
The hardest segment is often new grads / junior developers, for structural reasons:
1) Junior hiring depends on growth and slack
Training juniors costs time from seniors. When teams are lean and risk-averse, they prefer:
- senior hires who can ship immediately
- fewer people with broader scope
- internal transfers
2) Interview pipelines got saturated
After layoffs, the market has:
- more experienced candidates applying broadly
- more competition for roles that juniors used to get
3) Internships and campus hiring are the first knobs to turn
Campus programs are often the easiest budget to reduce quickly.
This doesn’t mean “no opportunities.” It means the path is less linear and more portfolio-driven than it was during the 2021 hiring surge.
The uncomfortable truth: “Software developer” is splitting into multiple job markets
If you’re assessing the future, avoid treating “software development” as one market. It’s several.
Market A: Revenue-adjacent engineering (still strong)
Roles tied directly to revenue or cost savings tend to persist:
- payments, fraud, risk
- ad systems (with constraints)
- cloud cost optimization (FinOps tooling)
- data infrastructure that reduces operational cost
- B2B product engineering with clear contracts
Market B: Speculative consumer bets (more volatile)
When capital is expensive, leadership trims:
- experimental apps
- moonshots
- long-horizon R&D without measurable ROI
Market C: Regulated and safety-critical software (slow but durable)
Healthcare, defense, aviation, energy, and government are slower-moving but more stable and often under-discussed.
Market D: “AI-enabled software delivery” (growing, but changing skill demands)
AI doesn’t eliminate engineering; it changes the bottlenecks:
- clearer specs and product thinking matter more
- system design, integration, security, and reliability stand out
- data and evaluation become core engineering tasks
“Will there be no more opportunities for future developers?” A realistic answer
There will be opportunities, but they won’t look like the 2021 bubble.
Why software work persists
- Every company is now a software company in the sense that software is operational infrastructure.
- Systems need maintenance, security patching, migrations, compliance, observability.
- Legacy modernization is decades-long work.
- AI increases demand for integration, data plumbing, and governance.
What’s actually changing
- Fewer “easy-mode” entry paths where a bootcamp plus a basic portfolio guaranteed multiple offers.
- More emphasis on fundamentals, shipping ability, and demonstrable skills.
- More distributed teams and global competition in some segments.
How future developers can adapt (practically, not motivationally)
Build “proof of work” that maps to real teams
Resumes are weak signals; shipped artifacts are strong signals. Aim for projects that resemble production constraints:
- Auth, roles, and permissions
- Database migrations
- Background jobs/queues
- Rate limiting
- Observability (structured logs, metrics, tracing)
- Performance budgets
- CI pipelines and tests
- Cloud deployment with cost awareness
A simple but credible example: a small SaaS-style service with Stripe-like webhook processing (even mocked), idempotency keys, retries, and a dead-letter queue.
Pick a stack, then go one layer deeper than most candidates
Being “full-stack” is fine, but “full-stack and deep in one area” is better.
Examples of “one layer deeper”:
- Web: browser performance, caching strategy, SSR/CSR tradeoffs
- Backend: concurrency, transaction isolation, message queues, API versioning
- Data: batch vs streaming, data quality checks, warehouse modeling
- DevOps: container security, IaC, incident response basics
Learn to talk about tradeoffs like an engineer, not a tool user
Many interviews are about reasoning:
- Why Postgres vs DynamoDB?
- When do you introduce a queue?
- How do you prevent double-processing?
- What breaks during a deploy and how do you roll back?
Target “software-rich” non-tech sectors
If your only target list is household-name tech firms, you’re voluntarily compressing your opportunity set. Consider:
- healthcare IT
- logistics and supply chain
- manufacturing and industrial IoT
- insurance and risk
- energy (grid, trading, monitoring)
- government contractors (where eligible)
What the layoff wave teaches about choosing employers
Layoffs aren’t random; they correlate with business model and capital structure.
Evaluate these signals before joining
- Profitability: Is the company cash-flow positive?
- Revenue concentration: One customer? One ad channel?
- Burn multiple (for startups): how efficiently it converts spend into growth
- Runway: months of cash left at current burn
- Headcount growth rate: did it double too fast?
- Product-market fit: is churn low? renewals strong?
Not all layoffs are avoidable, but you can reduce exposure.
Evidence and sources for key claims (links you can verify)
Here are reputable sources to validate the major drivers discussed:
- Monetary policy and interest rate changes (cost of capital)
- Federal Reserve FOMC: https://www.federalreserve.gov/monetarypolicy/fomc.htm
- FRED Federal Funds Rate: https://fred.stlouisfed.org/series/FEDFUNDS
- E-commerce/digital demand shift during and after COVID
- U.S. Census Retail / E-Commerce: https://www.census.gov/retail/index.html
- Software developer occupational outlook (long-run demand)
- BLS OOH Software Developers: https://www.bls.gov/ooh/computer-and-information-technology/software-developers.htm
- Macro job openings and labor market churn
- BLS JOLTS: https://www.bls.gov/jlt/
- Public tech layoff aggregation (useful but not definitive)
- Layoffs.fyi (crowdsourced aggregation; verify with company filings/news): https://layoffs.fyi/
- Venture funding cycles (capital availability)
- PitchBook (research and reports; often summarized publicly): https://pitchbook.com/news
- NVCA (U.S. venture data and reports): https://nvca.org/research/
(For venture data, some reports are paywalled; NVCA summaries are usually accessible and useful for trend confirmation.)
The bottom line: a post-bubble market, not the end of software careers
The post-COVID period created a distorted reference point: rapid hiring, inflated compensation bands in some regions, and unusually high junior throughput. The correction has been painful and visible because it hit famous companies all at once.
But the underlying drivers that create software work—digitization, security needs, data systems, automation, and now AI integration—haven’t disappeared. What changed is the pricing of risk and the patience for unprofitable growth.
For future developers, the opportunity is still there. The strategy just has to be more deliberate: build credible proof of work, learn fundamentals that transfer across stacks, and broaden your target sectors beyond the logo set that dominates headlines.