How I Taught Myself to Code (Even After Studying Tech in School)

Spoiler: a degree doesn't automatically make you a developer.

I walked out of university with a certificate in hand. And I could not build a single thing.

Not a proper web app. Not a working API. I could define what a REST endpoint was, but writing one from scratch? Connecting it to a database? Deploying it somewhere real? No chance. I came out of university with theory in my head and nothing in my hands.

That realisation hit me harder than I expected. I had spent years in school. I had passed the exams. But when I sat down to actually build something, the screen just stared back at me.

Why School Wasn't Enough

This isn't a rant about my university. It's just an honest observation: these programmes teach you about technology, not with it. We had networking theory. Database concepts. A bit of Java here and there. But the gap between understanding a concept in a lecture and applying it in a real project is enormous, and school rarely bridges that gap.

I graduated knowing how to explain what an API was. I couldn't write one.

I knew what a database schema was. I couldn't query one from actual code.

I understood version control in theory. I had never used Git on a real project.

That's the gap nobody warns you about. And I had to close it myself.

Joining the Bootcamp

After graduation, I enrolled in a 12-month coding bootcamp. I was determined to actually learn this time, the practical way.

The difference was immediate. Instead of being taught about programming, I was forced to actually program. Break things. Debug them. Break them again. Build ugly UIs. Fix them. Build them again slightly less ugly.

I spent nights on freeCodeCamp, burned through Udemy courses, and watched more YouTube tutorials than I can count. I didn't wait for perfect conditions or the "right" starting point. I just started. Messy, confused, and slow.

And slowly, things started clicking.

The Moment Things Clicked

There's a specific feeling when it stops being confusing and starts being fluent. When you don't have to think about why a function returns what it returns. You just know. When you can look at someone else's code and follow the logic without getting lost.

I remember the first time I built a full-stack app that actually worked end-to-end. Frontend talking to backend, backend talking to a database, data coming back and rendering on screen. It felt surreal. Like, I made this. From nothing.

That's when I knew I wasn't just studying code anymore. I was becoming a developer.

What the Self-Taught Mindset Actually Means

People hear "self-taught" and think it means going it alone. It doesn't. It means taking ownership of your own learning instead of waiting for someone to teach you.

Here's what that looked like for me in practice:

Building over watching. Tutorials are useful but they create an illusion of progress. The real learning happens when you close the tutorial and try to do it yourself from memory. It'll break. That's the point.

Reading the actual docs. Not just blog posts or Stack Overflow answers. The official documentation. It's denser, but it's the source of truth. Training yourself to read docs is one of the highest-leverage skills you can develop early.

Getting comfortable being broken. Errors aren't failures. They're feedback. The fastest developers I know aren't the ones who write perfect code, they're the ones who debug fast. Embrace the red text.

Shipping ugly things. Your first projects will not be impressive. Ship them anyway. They're proof you can finish something, and finishing is its own skill.

Where I Am Now

I'm a full-stack engineer working across the MERN stack, Next.js, React Native, Docker, AWS, and more. I've built and deployed real products with actual users. I've set up CI/CD pipelines and managed cloud infrastructure.

None of that came from school. It came from years of deliberate, hands-on building after the lectures were done.

The degree wasn't useless. It gave me context. But the skills? Those came from staying up late, breaking things, and refusing to stop until I understood why.

If You're in That Phase

If you just finished school and realised the same thing I did, that the degree didn't make you a developer, you're not behind. You're exactly where most people are. You just happen to be honest about it.

You don't need to know everything before you start.
You don't need the perfect roadmap.
You don't need to be ready.

Start messy. Build ugly things. Debug them slowly. Ship anyway.

The gap closes one project at a time.

I write about building real products as a developer from Accra. The technical decisions, the setbacks, and everything in between.