I don't have a computer science degree. I have a job writing software, and I've had one for a while now. For about a year before that, I did almost everything you're "supposed" to do to make up for the missing degree — and I want to tell you that it worked, because then this would be a nicer story. It didn't. The things I did to compensate for not having a degree were a dead end, and the thing that actually got me hired had nothing to do with the degree at all.
Here's the part that took me far too long to understand: a degree is not the thing employers want. It's a stand-in for the thing they want. And I spent months building a worse stand-in instead of just handing them the real thing.
What I thought "no degree" meant (and what it actually meant)
When you don't have the degree, the whole world tells you the same thing: you have a gap, so go fill it. So I did. I collected certificates — the free ones, then the ones with a logo people recognize. I started a LeetCode streak because a forum told me that's how you prove you're "rigorous" like the CS grads. I enrolled in enough of a bootcamp to get a bootcamp line on my résumé.
Every one of those was me trying to build a replacement credential. A thing I could point at and say: see, I'm as legitimate as the degree. I was playing the degree's game, just with cheaper pieces.
And it got me nothing. Not one interview traced back to a certificate. Not one interviewer asked about my LeetCode. The bootcamp line never came up in a room where someone decided whether to hire me. I had spent months manufacturing proof of the wrong thing.
The rule: when you don't have the credential, the instinct is to build a substitute credential. That's the trap. A certificate is a weaker copy of a degree, and nobody was ever going to want your weaker copy of the thing they already don't fully trust.
The question the degree is actually answering
Here's the reframe that changed everything, and it's the whole article, so I'll say it plainly.
When an employer sees a CS degree on a résumé, they are not thinking "ah, four years of theory." They're a human being trying to de-risk a hire, and the degree answers exactly one question for them:
"Will this person take something hard and ambiguous, with no syllabus and no answer key, and actually finish it?"
That's it. That's what the degree buys. Four years of someone being handed vague, difficult problems and grinding them to completion whether they felt like it or not. The employer doesn't care about the compiler-theory exam. They care that you've got a track record of finishing ambiguous hard things, because that's the entire job, and hiring someone who can't do that is expensive.
The degree is a proxy for finish-ability. A decent one — which is why it works as a filter. But it's a proxy. And once I saw that, the move was obvious and it was not "get a better proxy."
The rule: you cannot out-credential a degree. You will always lose that fight. So don't have it. Skip the proxy entirely and hand them the thing the proxy only gestures at — direct, checkable evidence that you finish hard things nobody scoped for you.
A certificate is also a proxy for finish-ability — a much weaker one, because everyone knows a course is scoped so you can't fail. That's precisely why it carries no weight. I'd been trying to beat a strong proxy with a weak proxy. The answer was to stop competing on proxies and show up with the real signal.
What the real signal looks like
The real signal is embarrassingly simple to describe and genuinely hard to fake: something you built that a stranger uses and that broke on you and that you kept running anyway.
That sentence has three load-bearing parts, and a tutorial project has none of them:
- A stranger uses it. Not you, not the instructor's spec — a person who does things you didn't plan for. A course project can't have this; the scope is fixed so you always win.
- It broke. Real usage produces real failure. The todo app from a tutorial never breaks, because nobody's hammering it at 9pm on a Saturday with input you didn't imagine.
- You kept it running. This is the finish. Not "I built it," which is the fun part, but "it fell over and I was the one who had to get up and fix it with no next-lesson button." That is the exact thing the degree was vouching for.
When you have that, the degree question doesn't just get answered — it stops being asked. Which brings me to the room.
The moment it actually stopped mattering
I'll give you the specific interview, because it's where the abstract thing became real.
Interviewer looks at my résumé, no degree line, and asks the question you're dreading — some polite version of "so, no formal background?" The old me would have gone into defense: listed the certs, mentioned the bootcamp, talked about how much I'd studied. Defending the weak proxy. It reads as exactly what it is — an apology.
Instead I said: "Right — let me tell you about the booking tool I built for a small business. It double-booked two real customers on a Saturday because of a race condition in my code, the owner called me, and I found it and fixed it that morning before they reopened." And I watched the question evaporate. We spent the next twenty minutes on the race condition. Nobody came back to the degree, because I'd just answered the only thing the degree was ever a proxy for, with a story that was checkable and specifically mine.
The rule: you don't win the "no degree" conversation by defending the gap. You make the gap irrelevant by answering — before they can even finish asking — the one question the degree was standing in for. A real war story closes that door in a sentence. A certificate reopens it.
The difference between "I studied this" and "this happened to me and I handled it" is the difference between a proxy and the real thing. One of them is a vibe. The other is checkable, and in the room, checkable wins.
The uncomfortable part: how I shipped enough real things in time
Here's the bit that stings, and I'd rather say it straight. You cannot produce that signal from reading. The signal only exists on the other side of shipped and used, and you need more than one, and you don't have four years. There's a brutal chicken-and-egg here: the evidence that gets you the job can only be made by doing the job, and nobody's employing you to do it yet.
The only way I got through it was to stop treating "build the app" and "understand the app" as the same task. I'd get something live as fast as I possibly could — real database, real URL, a real person able to hit it — and then go back and read it, break it on purpose, and rebuild the parts I didn't understand. Backwards from how courses teach it. It's also the only order that produces a real user, because a thing that's live is a thing that can break on you, and a thing that breaks on you is the only thing that generates a war story.
The rule: a deployed app with one real user teaches you more in a week than a tutorial does in a month — because the user does the thing you swore nobody would do, and now it's your problem with no answer key. That problem is the curriculum, and it hands you the exact fundamentals you need in the exact order you need them.
I learned more real fundamentals debugging that live booking race than in every course combined. The point was never "don't learn." The point is that the live app was the learning, and it also happened to be the evidence. One activity, both outputs.
If you're where I was
You don't need my exact path and you definitely don't need my mistakes. Stop manufacturing proof of the wrong thing and start manufacturing the right one:
- Quit collecting proxies. One more certificate will not move the needle. You are not trying to look as legitimate as a grad; you're trying to make legitimacy irrelevant.
- Pick something one real person actually needs. Not a clone. Your cousin's bookings, your own invoices, the spreadsheet your team is drowning in. Small and real beats big and fake, every time.
- Ship it before it's good. A live URL with one user beats a flawless repo with none. Deploy embarrassingly early — the point is to get it into the hands that will break it.
- Then go understand what you shipped. Break it on purpose. Read your own code like a stranger wrote it. That's where fundamentals finally stick and where the war stories come from.
- Keep the war stories. Every "it broke and I fixed it" is a sentence that answers the degree question and out-performs your entire skills list in the room.
The degree gets people past some automated filters, and I won't pretend it doesn't — I got rejected by plenty of them. But filters aren't where you get hired. You get hired in the room, by a human de-risking a decision, and in that room the only thing that moves is evidence you can take something ambiguous, make it real, and keep it running when it breaks.
The rule: the fastest way to look like a senior while you're still a junior — and the fastest way to make "no degree" a non-event — is to have already shipped something that survived contact with a real user. You can't fake that. And you don't need a degree to have it.
