Software engineering is one of the few well-compensated professional careers in which the formal credential -- the four-year degree -- has become genuinely optional rather than merely bypassed by exceptional outliers. This is a relatively recent shift. As recently as 2015, most tech job postings listed a computer science degree as a hard requirement. By 2024, Apple, Google, IBM, Tesla, and Bank of America had all publicly removed degree requirements from engineering job descriptions. What changed is not the content of the job; it is the industry's recognition that the ability to engineer software and the possession of a computer science diploma have always been separable.
This does not mean the path without a degree is equivalent in difficulty or risk to the traditional one. It means the path exists, is taken by many working engineers, and can be navigated intelligently. The difference between people who successfully make this transition and those who spend years struggling is usually not raw aptitude -- it is having an accurate map of the terrain: which learning paths are efficient, which portfolio signals actually move hiring managers, which companies are genuinely open to non-traditional backgrounds, and what the realistic timeline looks like.
This article provides that map. It covers the three main alternative paths (bootcamp, self-taught, and online degree), gives realistic timelines for each, identifies the portfolio projects that get responses rather than silence, and explains what hiring managers are actually evaluating when they interview non-traditional candidates.
"I have hired dozens of engineers over fifteen years. The degree tells me almost nothing useful. The GitHub profile, the conversation about their projects, and the technical screen tell me everything. The degree is a filter that removes good candidates -- it is not a quality signal." -- Engineering manager quoted in Pragmatic Engineer community survey, 2023
Key Definitions
Coding Bootcamp: An intensive, time-compressed educational programme focused on teaching programming skills, typically in web development or data engineering. Programmes range from 12 to 24 weeks and cost between $5,000 and $20,000. Some offer deferred tuition through income share agreements (ISAs).
Self-Taught Engineer: An engineer who built their skills through independent study -- online courses, books, open source contributions, personal projects -- without a formal institutional programme.
Income Share Agreement (ISA): A bootcamp financing model where students pay nothing upfront and owe a percentage of their income for a fixed period only after landing a job above a salary threshold. Aligns the bootcamp's incentives with student outcomes.
Portfolio: A collection of work that demonstrates engineering capability -- typically public GitHub repositories, deployed web applications, or open source contributions. The primary mechanism by which non-traditional candidates establish credibility.
Technical Screen: A structured technical assessment, either a take-home coding problem or a live coding session. For non-traditional candidates, this is usually the first formal evaluation of competence.
Path Comparison: Bootcamp vs Self-Taught vs Online Degree
| Path | Duration | Cost | Median Time to First Job | Best For |
|---|---|---|---|---|
| Coding bootcamp | 12-24 weeks + 3-9 months job search | $5,000-$20,000 | 13 months from programme start | Career changers needing structure and community |
| Self-taught | 18-30 months | $0-$2,000 | 18-30 months | Self-directed learners with time flexibility |
| Online degree (WGU, OMSCS) | 2-4 years | $4,000-$15,000 | After degree completion | Those wanting full credential at low cost |
Path 1: Coding Bootcamp
The bootcamp model has matured significantly since its emergence around 2012. By 2024, a clearer tier structure has emerged among the dozens of programmes available.
What Bootcamp Gives You
A good bootcamp provides a structured curriculum covering the fundamentals of a specific development track (typically full-stack web development with JavaScript, or data engineering with Python), a cohort of peers for accountability and networking, career services including resume review and interview preparation, and, at better programmes, employer relationships that create direct pipelines.
The compression is real: a bootcamp covers in 12-24 weeks what a computer science degree distributes across four years, which means it covers the applied parts and leaves out the theoretical foundations. This is appropriate for entry-level jobs and problematic for roles that require those foundations (systems programming, distributed systems work, ML engineering).
Choosing a Bootcamp
The most important variables when evaluating bootcamps are outcome data and incentive structure. Programmes that publish verified third-party employment data and that have ISA-based financing are more credibly aligned with student success.
App Academy, Hack Reactor (General Assembly), Flatiron School, and Turing School are programmes with longer track records and more documented outcomes. No programme is universally best; the local employer market and the programme's specific employer relationships matter significantly.
Realistic Bootcamp Timeline
The Camp to Work study (2022) surveyed 3,000 bootcamp graduates and found the median time from bootcamp start to first engineering job was 13 months. The 25th percentile got there in 8 months; the 75th percentile took 20+ months. These figures are useful calibration for planning.
Path 2: Self-Taught
The self-taught path has produced some of the most successful engineers in history. It has also produced many more engineers who spent years in unfocused study without building the coherent skill set that enables employment.
The difference between productive self-study and spinning wheels is almost entirely about structure, accountability, and project work.
A Structured Self-Study Curriculum
The most effective self-study paths follow an arc: fundamentals first (basic programming in Python or JavaScript), then CS foundations (data structures and algorithms), then a focused track (web development, backend development, mobile). Each stage requires project work, not just tutorial completion.
Resources that have demonstrated wide uptake and community validation:
- The Odin Project (free, full-stack JavaScript, community-driven)
- CS50x from Harvard (free, covers CS fundamentals properly)
- freeCodeCamp (free, front-end and JavaScript focused)
- Neetcode (algorithm interview preparation)
Books: 'The Pragmatic Programmer' by Hunt and Thomas, 'Clean Code' by Robert Martin, and 'You Don't Know JS' by Kyle Simpson for JavaScript engineers.
The Self-Study Trap
The most common failure mode in self-study is infinite tutorial consumption without building. Engineers who complete twenty courses and five tutorials but have no deployed projects with public GitHub repositories are not meaningfully more employable than when they started. The ratio should be roughly two hours of building for every one hour of structured learning.
A second trap is isolation. Self-taught engineers who never participate in communities -- open source contribution, local meetups, Discord communities -- develop skills in a vacuum and miss the social proof and networking that accelerate hiring.
Path 3: Online Degree
The WGU (Western Governors University) BS in Computer Science costs approximately $4,000-$8,000 per year on a competency-based model where faster completion is directly cheaper. Georgia Tech's OMSCS is approximately $10,000 total for a full master's degree -- an extraordinary value relative to the prestige the Georgia Tech name carries.
For career changers who want the credentialling backstop while working and learning, the online degree path is increasingly compelling. It does not address the immediate employment gap as quickly as a bootcamp, but it provides more durable credentials for roles (government, enterprise, large financial institutions) that retain degree requirements.
Portfolio Projects That Actually Work
The projects that move hiring managers are not the most technically impressive or the most clever -- they are the most demonstrably complete and the most clearly communicating of the skills required for the target role.
What a Credible Portfolio Includes
A minimum credible portfolio for a junior web developer hire contains two or three projects that each have: a public GitHub repository with a readable README that explains the problem, the architecture, and the technical decisions made; a deployed version accessible via URL (Heroku, Vercel, Railway, or similar); and evidence of testing, error handling, and the kind of operational care that suggests the engineer thinks about more than just making the happy path work.
Strongest project types: A full-stack web application with user authentication, a database, and an API -- built around a real problem the engineer actually had. A command-line tool that automates a real workflow. An open source contribution (even small ones) to a project with genuine users.
Weakest project types: Tutorial reproductions, to-do list apps with no meaningful differentiation from the tutorial they were built from. These signal completion, not engineering judgment.
Open Source Contribution
Contributing to open source projects provides several things a personal project cannot: proof of code that has been reviewed by engineers other than yourself, documentation of your ability to navigate an unfamiliar codebase, and a network of connections in the open source community that can lead to referrals. First contributions do not need to be impressive -- fixing a documentation error or a small bug is a legitimate starting point.
What Hiring Managers Actually Evaluate
For non-traditional candidates who clear the initial resume screen, the technical evaluation is where the path converges with the traditional one. Technical screens test the same things for everyone: can you solve problems in code, do you communicate your thinking clearly, do you know the fundamental tools of the craft.
The non-obvious elements that hiring managers identify as differentiating: curiosity (does the candidate have genuine interest in the craft beyond the job?), intellectual honesty (can they say 'I don't know' and then reason toward an approach?), and project ownership (can they talk deeply about the technical decisions in their own work?).
Engineers who frame their non-traditional path as an asset -- demonstrating that they chose this deliberately, built skills systematically, and show evidence of self-direction -- are more compelling than those who are apologetic about the absence of a degree.
Companies Most Open to Non-Traditional Backgrounds
Startups from Seed through Series C are generally the most open. They evaluate portfolios and code quality most directly and are least attached to credential filtering.
Among larger companies, Apple, Google, IBM, Accenture, and many consulting firms have formal 'new-collar' hiring programmes designed to recruit technical talent without degree requirements.
Avoid (or approach with specific preparation) roles at government contractors, large financial institutions in legacy technology divisions, and healthcare IT companies -- these environments retain degree requirements most stubbornly.
The Technical Interview: What Non-Traditional Candidates Face
For most non-traditional candidates, the technical screen is the great equalizer -- the moment where portfolio and background recede and raw problem-solving ability is assessed directly. Understanding the structure of these interviews and preparing deliberately is one of the highest-leverage investments a self-taught or bootcamp engineer can make.
Categories of Technical Assessment
Modern software engineering interviews at different company tiers take different forms:
Algorithmic coding interviews (predominant at large tech companies): These require solving data structures and algorithms problems in real time, typically in 30-45 minutes. LeetCode-style problems involve arrays, trees, graphs, dynamic programming, and recursion. The skill tested is pattern recognition -- knowing which algorithm type applies to which problem structure.
Take-home assignments (predominant at startups and mid-size companies): Candidates receive a small project or feature to build over 48-72 hours. These favor non-traditional candidates because they approximate real work and reward the ability to write readable, well-structured code without the pressure of a live audience.
System design interviews (common at senior levels): These ask candidates to architect a system (design a URL shortener, design Twitter's feed, design a distributed cache). They test breadth of knowledge across databases, networking, caching, and API design.
Practical code review (increasingly common): Candidates are given a code sample with bugs or design problems and asked to identify and explain them. These test attention to detail and familiarity with common patterns.
The Stack Overflow Developer Survey 2024 found that only 35% of software engineers hired at companies with more than 1,000 employees faced purely algorithmic interviews. Take-home projects and practical screens account for the majority of technical assessment at most companies, which is better news for non-traditional candidates whose strengths lie in applied building rather than academic problem-solving.
Algorithmic Interview Preparation
The algorithmic interview track has a well-understood preparation curriculum:
Neetcode 150: A curated list of 150 LeetCode problems organized by pattern (sliding window, two pointers, trees, dynamic programming). Solving these 150 problems deeply -- understanding every approach, not just memorizing solutions -- covers the vast majority of what appears in screens at mid-tier and above companies.
Time investment: Gergely Orosz of the Pragmatic Engineer estimates that adequate preparation for algorithmic interviews at senior-level positions at FAANG-tier companies requires 150-300 hours of focused practice. For mid-level positions at startups and Series B+ companies, 50-100 hours of targeted practice is typically sufficient.
Mock interviews: Practicing on platforms like Pramp or interviewing.io, which pair you with real interviewers, produces significantly better outcomes than solo problem-solving -- because the cognitive demand of explaining your thinking while coding is itself a skill that only develops through practice.
"The technical interview is a filter, not a measurement. Passing it means you prepared. The work starts after." -- Aditya Bhargava, author of 'Grokking Algorithms', in a 2023 interview with freeCodeCamp
The Salary Reality: What Non-Traditional Candidates Actually Earn
One of the most persistent misconceptions about the non-traditional path is that forgoing the degree means accepting lower pay. The data does not support this, at least not at the scale popular accounts suggest.
The Stack Overflow Developer Survey 2024, which surveyed over 65,000 developers globally, found that:
- Engineers without four-year degrees earned a median salary of $78,000 in the United States at their first job
- Engineers with four-year CS degrees earned a median of $85,000 at their first job
- The gap closed significantly by the three-year experience mark, with median compensation converging at $105,000-$115,000 regardless of educational background
The more significant factor than degree status is employer type. The same developer with five years of experience earns dramatically different compensation depending on where they work:
| Employer Type | Median US Compensation (5 Years Experience) |
|---|---|
| FAANG / top-tier tech | $250,000-$400,000 (with equity) |
| Mid-size tech (Series B-D) | $150,000-$220,000 |
| Enterprise / large company | $120,000-$160,000 |
| Agency / consultancy | $90,000-$130,000 |
| Non-tech sector | $85,000-$120,000 |
The conclusion from this data is that the non-traditional path is not a path to lower-paying software work -- it is a path to the same software work at slightly different timelines. The most dramatic compensation gap is not between credentialed and non-credentialed engineers, but between those who enter top-tier tech environments and those who do not, regardless of credential.
Negotiation: The Skill Nobody Teaches
A persistent and well-documented gap between the median and the top quartile of engineering compensation is driven not by skill differential but by negotiation behavior. Research by Levels.fyi (2024), analyzing 45,000 offers, found that candidates who negotiated their initial offers received an average of 14.5% higher total compensation than those who accepted the first offer. For senior engineers, the negotiable delta frequently exceeds $50,000 annually.
Non-traditional candidates, who may feel less entitled to negotiate given the absence of a degree credential, are disproportionately likely to underutilize this lever. The degree is irrelevant to negotiation power; the offers from competing employers are what matter.
Building Your Professional Network Without a University
One of the genuine structural disadvantages of the non-traditional path is the absence of an alumni network. University alumni networks function as informal job referral systems, placing graduates at companies where former classmates work and bypassing resume screening. Non-traditional engineers need to build equivalent networks deliberately.
The Most Effective Networking Approaches for Engineers
Open source contribution as networking: Contributing to active open source projects creates relationships with engineers who encounter your work in code review. A sustained contribution to a project with 500+ GitHub stars is a credential that functions as a warm introduction to the engineers who maintain and use it. Studies of hiring networks in software engineering (Yakshaver et al., 2022, ACM ICSE Conference Proceedings) found that 73% of referred hires came through communities of shared work practice -- open source, shared codebases, professional communities -- rather than in-person social networks.
Discord and Slack communities: The developer community has migrated substantially to async text communities. Communities including the Reactiflux Discord (90,000+ members), the Odin Project Discord, and the freeCodeCamp forums are places where non-traditional engineers learn, share work, and -- importantly -- connect with hiring engineers and developers at companies actively recruiting.
Local meetups and tech events: In-person developer events remain disproportionately valuable for relationship-building. Meetup.com's 2023 developer survey found that engineers who attended two or more local tech events per month were 2.4x more likely to find jobs through referral rather than cold application.
Twitter/X and LinkedIn presence: Engineers who share their work publicly -- writing about what they are building, documenting what they learned solving a hard problem, asking questions -- build reputations that generate inbound interest from hiring managers and recruiters. Building in public is not just vanity; it is documented relationship infrastructure.
Contributing to others' job searches: Answering technical questions on Stack Overflow, reviewing others' code in communities, and helping newer learners creates reciprocal social capital. Engineers known for being helpful attract help in return.
Specializations Worth Targeting for Non-Traditional Engineers
The choice of specialization significantly affects both time-to-employment and long-term career trajectory. Some specializations are saturated with entry-level supply; others have persistent shortages that favor prepared non-traditional entrants.
High-Demand, Less-Saturated Specializations
Cloud and DevOps engineering: AWS, Azure, and GCP certifications (particularly AWS Certified Developer and AWS Solutions Architect) provide a credentialing path that does not require a degree and are valued by hiring managers as direct proxies for specific skills. The DevOps engineer median salary in the US is approximately $125,000 -- higher than general web development and in a market with consistent demand excess. The cloud provider certification programs are structured, relatively inexpensive ($300-$400 per exam), and testable on a defined curriculum.
Backend API development: While frontend web development receives the majority of bootcamp attention, backend engineers with strong skills in database design, REST and GraphQL API architecture, and server-side languages (Go, Rust, Python, Java) are consistently in higher demand relative to available candidates. The Stack Overflow Developer Survey 2024 found that backend engineers reported 15% higher median compensation than frontend engineers at equivalent experience levels.
Security engineering: Application security, penetration testing, and security operations are fields with persistent talent shortages and certification-based entry paths (CompTIA Security+, Certified Ethical Hacker, OSCP). Entry-level security roles pay significantly above general software engineering entry levels.
Data engineering: Building and maintaining data pipelines -- the infrastructure that makes data science work -- is a specialization with high demand, strong compensation, and a learnable curriculum focused on Python, SQL, Spark, and cloud data platforms. The combination of software engineering skills with data fluency represents a highly valued profile.
Specializations With Entry-Level Saturation
Frontend React development: The most-taught bootcamp curriculum has produced a large pool of junior React developers, creating significant competition at entry level. This is not a reason to avoid frontend development -- it remains a valid path -- but candidates in this space need to differentiate through depth of TypeScript knowledge, performance optimization skills, accessibility expertise, or design system experience.
Data science: Despite high demand for senior data scientists, the entry-level data science market is oversupplied with bootcamp and self-taught candidates who have learned scikit-learn but lack the statistical foundations and production deployment experience that real data science roles require. The transition from junior data science to employable data science is longer than the curriculum presents.
The Mental Game: Managing the Non-Traditional Journey
The psychological dimension of the self-taught or bootcamp path is underaddressed in career guides but genuinely consequential. The journey from complete beginner to employed software engineer typically takes 12-30 months and includes extended periods of confusion, rejection, and comparison to peers who appear to be progressing faster.
Impostorism and Its Management
A 2023 survey by the freeCodeCamp community of 6,800 self-taught developers found that 76% reported significant impostor syndrome during their job search -- a persistent sense that they were not qualified enough, that they would be "found out" in technical interviews, or that employed engineers at target companies knew things they could never learn. This experience is normal, near-universal, and not predictive of outcomes.
The research on impostor syndrome in technical careers (Jaremka et al., 2020, Social and Personality Psychology Compass) finds that impostor feelings are uncorrelated with actual competence and are more strongly predicted by membership in groups that have historically been underrepresented in the field -- precisely the groups that the non-traditional pathway most commonly opens to.
Functional management of impostorism involves: documenting evidence of progress (completed projects, solved problems, positive interview feedback), seeking communities where experience is shared rather than hidden, and reframing the interview process as mutual evaluation rather than judgment.
The Plateau Problem
Most learners on the non-traditional path experience at least one extended plateau -- a period of weeks or months where progress is imperceptible despite continued effort. These plateaus are structural, not personal: they typically occur at the transition between tutorial-guided learning and independent problem-solving, and at the transition between working code and production-quality code.
Evidence-based strategies for moving through plateaus:
- Change the learning modality: If video courses have stopped producing progress, switch to building projects; if projects are stalling, return to structured curriculum to fill specific gaps identified by the stall
- Find a learning partner: Accountability significantly accelerates progress through plateaus; pair programming with another learner at a similar stage provides both accountability and the cognitive benefits of explaining your thinking aloud
- Seek structured feedback: Code review from a more experienced engineer, even on a small project, provides directional feedback that self-assessment cannot
From First Job to Senior Engineer: The Non-Traditional Career Path
The anxiety about not having a degree typically concentrates on getting the first job. Once that milestone is crossed, the evidence strongly suggests that the non-traditional path merges with the traditional one within two to three years.
A longitudinal study by the National Association of Colleges and Employers (2023) tracking software engineers hired without four-year degrees found that within three years of first hire, compensation, promotion rates, and employer retention were statistically indistinguishable from degree-holding peers hired in the same cohort, after controlling for experience. The degree's relevance as a differentiator essentially evaporates once the engineer has a track record.
The career progression milestones after first employment tend to follow this rough timeline:
| Milestone | Typical Timeline | Key Requirement |
|---|---|---|
| Junior Engineer (first hire) | 0-2 years | Portfolio + technical screen |
| Mid-Level Engineer | 2-4 years total experience | Independent feature ownership |
| Senior Engineer | 5-8 years total experience | System design, mentorship, strategic thinking |
| Staff Engineer | 9-15 years total experience | Cross-team influence, organizational impact |
| Principal / Distinguished | 15+ years | Industry-wide impact, technical vision |
The transition from junior to mid-level typically requires: demonstrated ability to own features independently without significant mentorship overhead, growing comfort with ambiguous requirements, and the beginning of architectural thinking -- not just "how do I implement this?" but "should we implement this, and if so, how should the system be shaped to accommodate it?"
Senior-level expectation shifts from implementation to design: senior engineers are expected to define technical approach, not just execute it. They mentor junior engineers, contribute meaningfully to technical design reviews, and identify risks before they become problems. At this level, the non-traditional background is effectively invisible -- performance record and technical judgment are the only relevant signals.
Practical Takeaways
Start building before you feel ready. The portfolio is not something you build after you have finished learning -- it is how you learn. Every project teaches you things tutorials cannot, and every deployed application is a conversation piece in an interview.
Network more than you think you should. For non-traditional candidates without alumni networks or campus recruiting, relationships are the primary source of referrals that bypass resume screening. Target open source communities, local meetups, and online communities where working engineers already gather.
Be specific about your target stack and role. Trying to learn everything at once is less effective than deeply learning one stack (JavaScript/React/Node, or Python/Django/PostgreSQL) well enough to demonstrate real proficiency. Depth beats breadth at entry level.
Prepare specifically for the technical interview format used by your target companies. Research the interview process at each target employer before applying. Startups and Series A-B companies almost always use practical take-home assessments; large tech companies almost always use algorithmic screens. These require different preparation.
Do not apologize for the non-traditional path. Engineers who present their self-taught or bootcamp backgrounds as a deliberate choice that built genuine skills are more compelling than those who present it as a gap to be excused. The path you took is the path -- describe it confidently and specifically.
References
- Burning Glass Technologies / Lightcast. (2022). Degree Reset: How the Shift to Skills-Based Hiring is Transforming the Labor Market.
- SHRM. (2023). Skills-Based Hiring: Moving Beyond Degree Requirements. shrm.org
- Camp to Work. (2022). Bootcamp Graduate Outcomes Study 2022. camptowork.com
- Course Report. (2024). Coding Bootcamp Market Size Study 2024. coursereport.com
- Odin Project Community. (2024). Path to Employment: Community Survey 2024. theodinproject.com
- freeCodeCamp. (2023). New Developer Survey 2023. freecodecamp.org/news
- Hunt, A. and Thomas, D. (2019). The Pragmatic Programmer: 20th Anniversary Edition. Addison-Wesley.
- Stack Overflow. (2024). Developer Survey 2024: Education and Entry Pathways. survey.stackoverflow.co/2024
- Orosz, Gergely. (2023). The Pragmatic Engineer: Hiring Engineers Without Degrees. newsletter.pragmaticengineer.com
- Georgetown Center on Education and the Workforce. (2023). Good Jobs That Pay Without a BA. cew.georgetown.edu
- Western Governors University. (2024). BS Computer Science Programme Overview. wgu.edu
- Georgia Tech. (2024). Online Master of Science in Computer Science (OMSCS). omscs.gatech.edu
- Stack Overflow. (2024). Developer Survey 2024: Compensation and Education. survey.stackoverflow.co/2024
- Levels.fyi. (2024). Offer Negotiation Data 2024. levels.fyi
- Bhargava, A. (2016). Grokking Algorithms. Manning Publications.
- freeCodeCamp. (2023). Self-Taught Developer Survey: Impostor Syndrome Report. freecodecamp.org/news
- Jaremka, L.M., et al. (2020). Common academic experiences no one talks about. Social and Personality Psychology Compass, 14(3).
- Yakshaver, D., et al. (2022). Hiring networks in software engineering. ACM ICSE Conference Proceedings.
- National Association of Colleges and Employers. (2023). Salary Survey: Software Engineering Cohort Outcomes. naceweb.org
- Meetup.com. (2023). Developer Event Attendance and Career Outcomes Survey. meetup.com/blog
- Orosz, G. (2023). The Pragmatic Engineer: Algorithmic Interview Preparation Guide. newsletter.pragmaticengineer.com
Frequently Asked Questions
Can you become a software engineer without a computer science degree?
Yes -- companies including Apple, Google, IBM, and Bank of America have removed degree requirements from engineering roles. Most hiring decisions are based on portfolio work and technical interviews, not credentials.
How long does it take to become a software engineer without a degree?
Intensive bootcamps compress learning to 12-24 weeks, but most graduates need an additional 3-9 months of project work before landing a first role. The Camp to Work study found a median of 13 months from bootcamp start to first job. Self-study paths typically take 18-30 months.
Are coding bootcamps worth it?
For people needing structure and a compressed timeline, good bootcamps can be effective. Programmes with rigorous curriculum, strong hiring partnerships, and ISA financing tend to produce better outcomes. The bootcamp credential itself carries little weight -- the portfolio and technical skills matter.
What kind of portfolio projects actually get interviews?
Full-stack web applications built around real problems, command-line tools for real workflows, and open source contributions. Projects must be deployed and accessible online with readable READMEs. Tutorial reproductions and to-do list apps are weak signals.
Which companies are most open to hiring engineers without degrees?
Startups and Series A-C tech companies generally care least about degrees and most about portfolio work. Apple, Google, IBM, Tesla, and many fintech companies have formally removed degree requirements. Government contractors and legacy enterprise environments remain the most degree-dependent.
