The software salary debate usually turns into two groups yelling past each other. One side sees a junior developer making $90k or $100k and says tech is overpaid, while the other side sees a staff engineer keeping a giant system alive and says developers are underpaid compared to the money they help companies make. Both sides can be right depending on what kind of developer they are talking about, but the conversation usually falls apart because people use one job title to describe a bunch of completely different jobs.
A junior dev building admin screens, a mid-level dev fixing production bugs, a staff engineer designing systems across teams, and an AI engineer working near model infrastructure are all technically “developers,” but they are not living in the same labor market. Some of that work is closer to skilled trade work with a keyboard, some of it is business automation work, some of it is infrastructure work, and some of it is high-scale technical decision-making where one bad call can cost a company a lot of money.
I also do not like when developers act like software is the only hard work that exists. I have been a roofer, I was a medic in the Army, I worked private security, and I have done warehouse-style work loading roofing materials onto job sites, so it is hard for me to listen to someone act like fixing a React bug is automatically harder than climbing a roof, treating people under pressure, standing a post all night, or throwing heavy material around in bad weather for less than $20 an hour.
At the same time, I do not like fake arguments that pretend software work is easy just because it is not physically brutal. A job can be easier on the body and still be valuable to a company, because the company is not paying based on how much your back hurts. The company is paying based on leverage, replacement cost, scalability, risk, and how close the work sits to money.
That is the uncomfortable part. A junior developer can do work that looks simple, like fixing a form or wiring an API call, and still get paid more than someone doing harder physical work. That does not mean the junior developer is tougher or more useful to society. It means software sits inside a business model where one small piece of work can be reused, deployed, copied, and sold again and again.
Table Of Contents
- The Real Question
- Why I’m Comparing These Jobs At All
- The Pay Numbers That Start The Argument
- Salary Comparison Graphic
- Why A Junior Dev Can Make More Than People Doing Harder Work
- Roofing Compared To Software Development
- Army Medic Work Compared To Software Development
- Private Security Compared To Software Development
- Warehouse And Manual Labor Compared To Software Development
- Teaching Compared To Software Development
- Do Most Developers Even Do DSA?
- Is Web Development Skilled Trade Work With A Keyboard?
- Are Junior Developers Overpaid?
- Are Mid-Level Developers Fairly Paid?
- Are Staff Engineers Overpaid?
- Where AI Changes The Pay Conversation
- The Three Different Developer Economies
- The Honest Answer
- Sources
The Real Question
The real question is not “are developers overpaid?” because that question is too broad to be useful. A better question is, “overpaid compared to what, for what type of work, at what company, and under what business model?” Without those details, the argument turns into people comparing a junior web developer at a small company to a staff engineer at Google like those are the same thing.
If we compare developers to the national median worker, developers are paid a lot. If we compare developers to roofers, EMTs, paramedics, security guards, warehouse workers, construction laborers, or teachers, software pay can look insane, especially when the software job is remote and the other job is physically dangerous, emotionally heavy, or socially necessary.
If we compare developers to the money their work can generate, the answer changes. A developer working on a SaaS product, payment system, cloud platform, AI tool, ad system, internal dashboard, or automation flow can touch systems that scale to thousands, millions, or even billions of interactions. That kind of scale is why the salary conversation gets weird fast.
That is the part people miss when they only compare effort. The labor market does not pay only based on pain, danger, stress, intelligence, or how noble the job is. It mostly pays based on leverage, scarcity, replacement cost, company margins, and how close the work is to revenue.
This is why the argument feels morally wrong but economically explainable. A medic can do more socially important work than a junior web developer and still make less, because medical labor is often trapped inside public budgets, insurance structures, military pay tables, local contracts, or staffing models. Software work, especially inside product companies, can sit closer to high-margin revenue.
That does not mean the market is fair. It means the market is not built around fairness. It is built around money, risk, supply, demand, and who has the power to negotiate.
Why I’m Comparing These Jobs At All
I am not comparing software to roofing, Army medic work, private security, warehouse-style labor, and case management because I think they are all the same job. I am comparing them because I have lived enough of those worlds to know that “hard work” and “high pay” are not the same thing, and pretending they are is one of the reasons the developer pay debate gets so fake.
My own work history did not start in tech. I served as a Healthcare Specialist in the Army from 2011 to 2014, including training environments and combat-zone medical support, where the work involved triage, emergency response, medical readiness, supplies, physical exams, medication administration, and staying calm when things were unpredictable. After that, I worked roofing and roofing supply roles from 2017 to 2020, including general contracting, tear-off, shingle work, site prep, cleanup, and roof loading heavy materials onto job sites in bad weather and under tight schedules. I also worked private security, and later worked in case management with Veterans Court, Drug Court, and Mental Health Court, where documentation, communication, crisis intervention, and keeping people on track mattered every day.
I also worked at Mason County Kitten Rescue from 2020 to 2022, which was not high-paying tech work, but it taught organization, intake, care routines, training volunteers, watching for signs of distress, and doing important daily work that does not become more profitable just because it matters. Then I started moving seriously into software, contributing as a Junior Frontend Developer with CIRIS Ethical AI in 2024 by running the project locally, improving onboarding and setup documentation, adding small code changes, improving token-verification logging, fixing lint issues, improving error messages, and opening GitHub Issues to keep larger ideas tracked. In 2025, I completed an on-site AWS Cloud Support Engineer internship in Seattle, where the work included guided support rotations in training environments with no customer data, guided Juniper and Junos troubleshooting labs in Jupyter Notebooks, and a capstone serverless metadata extraction workflow using Lambda, DynamoDB, S3, and an accessible frontend deployed on AWS Amplify.
The reason that timeline matters is because none of the earlier physical or service-heavy jobs paid me over $20 an hour at the time, but they still demanded discipline, pressure management, communication, safety, documentation, and the ability to keep moving when things were not comfortable. Then tech came along and suddenly the pay ceiling was completely different, not because the work became morally superior, but because the business model changed. Software is not automatically harder than those jobs, but it can be attached to systems where the output scales in a way those jobs usually cannot.
The Pay Numbers That Start The Argument
The U.S. Bureau of Labor Statistics listed the median annual wage for software developers at $133,080 in May 2024. The same BLS page says the lowest 10 percent earned less than $79,850, while the highest 10 percent earned more than $211,450.
That number is already high compared to normal American wages. BLS listed the median annual wage for all workers at $49,500 in May 2024, which means the median software developer made about 2.7 times the median worker.
The comparison gets uncomfortable when software is placed next to jobs that are clearly hard, risky, or socially important. BLS listed roofers at $50,970, EMTs at $41,340, paramedics at $58,410, security guards at $38,370, construction laborers and helpers at $46,050, hand laborers and material movers at $37,680, and high school teachers at $64,580.
Those numbers explain why people outside tech get annoyed when developers complain about pay. A junior developer can make more than a roofer, medic, security guard, teacher, construction laborer, or warehouse worker before that junior developer is even fully useful to the team.
Levels.fyi shows even larger numbers because it tracks total compensation, not just base salary. In May 2026, Levels.fyi listed U.S. software engineer median total compensation around $191,000, with the 25th percentile around $135,000, the 75th percentile around $276,100, and the 90th percentile around $380,000.
BuiltIn shows a lower junior number than Levels.fyi, which makes sense because BuiltIn pulls from a broader mix of companies. BuiltIn lists U.S. junior software engineer average base salary around $89,847, average additional cash compensation around $10,590, and average total compensation around $100,437.
| Role Or Group | Recent Pay Data | Why It Matters |
|---|---|---|
| All U.S. workers | $49,500 median wage | This is the broad baseline for the whole labor market. |
| Roofers | $50,970 median wage | This is skilled, physical, dangerous work, but the pay is close to the national median. |
| EMTs | $41,340 median wage | This is life-safety work, but the labor market pays it far below software. |
| Paramedics | $58,410 median wage | This pays more than EMT work, but still far below the median developer. |
| Security guards | $38,370 median wage | This is common risk-bearing work, but it pays far below software. |
| Construction laborers and helpers | $46,050 median wage | This is hard physical work that often pays less than many junior tech jobs. |
| Hand laborers and material movers | $37,680 median wage | This covers a lot of warehouse-style physical labor and shows how low that work often pays. |
| High school teachers | $64,580 median wage | This requires education, responsibility, and social value, but it is still below junior software pay in many cases. |
| Software developers | $133,080 median wage | This is where the comparison starts looking unfair to people outside tech. |
| U.S. software engineers on Levels.fyi | $191,000 median total comp | This includes bonus and equity, so it shows the higher end of tech more clearly. |
| Junior software engineers on BuiltIn | $100,437 average total comp | This is one reason people ask whether junior developers are overpaid. |
The table is not saying developers have easy lives or that every developer is rich. It is showing why the discussion gets tense, because the pay gap is real and the explanation is not as simple as “developers are smarter” or “developers work harder.”
The market is not judging pay by soreness, danger, or public good. It is judging pay by how much money the company has, how scalable the output is, how hard the role is to fill, and how expensive it is when the work is done badly.
Salary Comparison Graphic
OnDeck, Revenue Per Employee Rankings
SOCIAL SHARE CARD GENERATOR