Meet Alex. Never finished a computer science degree. Started learning to code at 19 because he was bored with his business degree and a friend showed him how websites worked. Built his first project in three months. Got his first freelance gig six months later. Now, five years in, he’s a senior engineer at a mid-size tech company making more than most of his peers with degrees.
By the credential system’s logic, Alex shouldn’t exist. He should be filtered out at the resume stage. Yet here he is, shipping code that matters, leading projects, being sought after by companies.
Alex isn’t alone. And his story reveals something the system doesn’t want to admit: the path to becoming a great engineer has almost nothing to do with how credentials suggest it should work.
The Self-Taught Programmer
Alex’s path was simple: learn by building. He didn’t take a Computer Science degree. He took online courses, built projects, broke things, fixed them, shipped them to real users. Every mistake taught him something that a textbook never could.
When he needed his first real job, he didn’t have a resume full of credentials. He had a GitHub profile full of projects. Real code. Real problems solved. A hiring manager looked at the projects, saw the quality, and took a chance. One chance was all he needed.
What Alex learned on his own that a CS degree rarely teaches: how to debug production code under pressure. How to learn a new framework in a week because he understood the underlying principles. How to work with a team, take feedback, iterate. How to ship something imperfect but functional and improve it later.
The irony? A lot of what he had to unlearn came from people *with* degrees who tried to teach him “the right way to do things.” Often there was no “right way.” There was just the way that worked, and the way that didn’t. Alex had learned to distinguish between the two through building.
His peers with CS degrees often struggled with the same thing: translating theory into practice. They could explain why something worked in principle but couldn’t figure out why it was failing in their codebase. Alex could, because he’d been debugging real code the whole time.
The Dropout Who Built Something
Then there’s Sam. Started a CS degree at a decent university. Took all the theoretical classes. But by sophomore year, realized something: everything interesting was happening outside the classroom.
Sam left. Not because they failed out. Not because they couldn’t handle it. But because the pace was too slow and the problems felt disconnected from reality.
For the next three years, Sam did what most people would call the risky thing: built a startup. It failed. Built another one. Failed again. Third one? Started gaining traction. Wasn’t a unicorn, but it was real revenue, real users, real problems being solved.
When that startup eventually got acquired, Sam’s lack of a degree didn’t matter. The acquirer was buying the product, the team, the capability. Sam had learned more in three years of building than any degree could have taught. Not just technical skills, but product sense, user empathy, how to make decisions with incomplete information, how to lead under uncertainty.
Sam’s credentials say “no degree, two failed startups.” But what those credentials don’t capture is the real education: how to think like an owner, how to prioritize ruthlessly, how to learn fast and adapt faster.
The Rule-Breaker With a Degree
Then there’s Jordan. Actually got the degree. Went to a good university. But spent most of it building unconventional projects and questioning why things were done a certain way.
Got mediocre grades because the assignments weren’t interesting and Jordan kept trying to solve them in ways the professors hadn’t anticipated. “That’s not the standard approach.” Same feedback, different teacher.
But here’s the thing: those same traits that got Jordan lower grades in school are exactly what made them valuable in the real world. The ability to look at a problem and ask “what if we did this differently?” The willingness to question the standard approach. The confidence to try unconventional solutions.
In school, this got penalized. In the industry, this is gold.
Jordan spent the first few years of their career unlearning what school had trained them to do: follow instructions perfectly, optimize for the expected answer, don’t take risks. The real value came not from the degree, but from the parts of Jordan’s personality that the degree almost crushed.
What These Stories Have in Common
Alex, Sam, and Jordan are different people with different paths. But they share something crucial:
They all succeeded by doing something the system doesn’t reward. Alex learned outside the system entirely. Sam left the system to build something real. Jordan got mediocre grades because they refused to play by the system’s rules.
None of them succeeded *because* of credentials. Some despite credentials, some without them. But none of them succeeded by optimizing for the credential.
What they all optimized for instead was actual learning. Real problems. Building things. Shipping code. Getting feedback. Iterating. The messy, non-standardized, non-measurable process of actually becoming competent.
This is the pattern that keeps showing up in tech. The people who become genuinely great engineers are almost never the ones who followed the standard path perfectly. They’re the ones who deviated from it, took risks the system doesn’t reward, and learned through building instead of listening.
The credential helped some of them (Jordan could at least get interviews), but it was never the source of their actual capability. The capability came from doing the work, making mistakes, and learning from them.
The System’s Blind Spot
Here’s what’s interesting: the system still works. Alex, Sam, and Jordan all got hired, all succeeded, because at some point someone took a chance on them based on demonstrated capability rather than credentials.
But for every Alex, Sam, and Jordan who made it through, how many others didn’t because they never got a chance? How many talented people are still filtered out at the resume stage because they don’t have the right credentials, even though they could do the work?
The system filters based on credentials. The system finds real talent anyway, but only if the talent is lucky enough to break through the filter. And most of the time, the people who break through are the ones who took risks and built things, which means they have *something* to show besides a degree.
What about the brilliant person who’s been learning but hasn’t shipped anything public yet? What about the person with an unconventional background who never had access to a computer science degree? What about the person whose talent just doesn’t fit neatly into the credential system?
They never make it through the filter. So we never know what we’re missing.
The Real Lesson
The stories of Alex, Sam, and Jordan show us something important: the system is breakable. Credentials matter less than we think. Actual capability matters more than we admit.
But they also show us something else: it takes luck, timing, and the willingness to take risks that most people won’t take. It takes having something to show besides a degree. It takes finding someone willing to look past the credential and see the actual person.
Alex, Sam, and Jordan made it. But they also chose paths that most people would be afraid to choose. They bet on themselves when the system said “get a degree first, then bet on yourself.”
The question is: why should people have to take those risks? Why can’t the system just recognize competence when it sees it?
Tomorrow, we’re going beyond tech. Because this pattern isn’t unique to engineering. It shows up everywhere. And everywhere it shows up, the story is the same: practical skills beat credentials, but credentials are still what get you through the door.
