My Shelf

They say a developer is only as good as their tools.
Well, in that case — call me Thor, because my stack is hammering bugs and lighting dreams daily.

After years of debugging, late-night Stack Overflow binges, and enough pep talk to qualify as a life coach, I’ve curated a tech stack that’s not just powerful — it’s personal. This isn’t just code. It’s a lifestyle.

So here it is: the arsenal of a full-stack ninja — battle-tested, vibe-approved, and recruiter-ready.

Frontend: Next.js + React + Typescript + Tailwind CSS

React

My ride-or-die.
React was the first library that made me feel like I wasn’t just writing websites — I was engineering experiences. With components, hooks, and JSX that feels like modern poetry (sometimes dark, tragic poetry), it’s the backbone of my UI game.

Next.js

If React is my lightsaber, Next.js is my Jedi training.
SSR, SSG, API routes, image optimization — this framework turns my React apps into performance beasts. Plus, routing without react-router? Yes, please. Let me just drop a file in /pages and call it a day.

TypeScript

Ah yes — TypeScript, my overly strict but deeply caring coding partner.

It’s the friend who taps your shoulder and says,

“Are you sure this function won’t return undefined?”

At first, it slowed me down. Now? It’s my guardian angel. No more mystery bugs from null, undefined, or typo-ridden props.
With TS, I build confidently — like a samurai who knows every swing will land clean.

Tailwind CSS

Tailwind is the love letter I never thought I’d write to utility classes.
Forget naming things like .hero-section-wrapper-max-v2. Tailwind lets me build fast, consistent, and dripping-with-style UIs. My designs? Sleek. My classes? Unreadable but effective.
10/10 would p-4 again.

State Management: Context API + useState + Custom Hooks

Redux who?
Most of my projects live happily on a diet of Context and useState, sprinkled with custom hooks that make my logic cleaner than your Sunday laundry.

And if things get messy, I break out the heavy-duty stuff like useReducer — because I like my state like I like my code: predictable and drama-free.

Backend: Node.js + Express + MongoDB

Node.js + Express

Lightweight, fast, and no-nonsense. Node + Express is the backend power couple I trust to build APIs that scale, deliver JSON like Glovo, and never ghost me in production.

MongoDB

I like things a little unstructured — call it a creative quirk.
MongoDB lets me model my data without getting trapped in a relational cage. Need to nest an object inside another object inside another? MongoDB: “Bet.”

And with Mongoose, I get just enough structure to keep things civilized without turning into a database abobi.

Deployment: Vercel + Render + GitHub

• Vercel for frontend — frictionless deployments, custom domains, and a dashboard that doesn’t make my brain hurt.
• Render or Railway for backend APIs and MongoDB instances — because Heroku decided to ghost us all.
• GitHub — the source of truth, chaos, and wildly emotional commit messages like:

"fixed it i think pls work this time"

Other Tools I Swear By

• Framer Motion – For animations smoother than my pickup lines.
• Postman – My therapist for testing APIs.
• VSCode + Prettier + ESLint – Clean code or bust.
• Figma – Because wireframes shouldn’t look like crime scene sketches.

Final Words from Your Full-Stack Guru

This isn’t just a stack.
This is years of trial, error, rage quits, and glow-ups.
Each tool in my toolbox has earned its place through broken features, tight deadlines, and moments where I whispered, “Please just work” into the void.

I know how to build it all — from pixel-perfect landing pages to backend APIs that slap.
I speak both frontend finesse and backend logic.
I deploy, I debug, I design.
I’m not just a full-stack developer. I’m the full meal.

Eager minds, fellow devs recruiters, startups — welcome to my workflow.
Let’s build something brilliant.

When I first met React, I thought:
“Oh wow, I bet this looks… clean.”
Then it handed me JSX, and I was like:
“Wait… is this HTML in my JavaScript or JavaScript in my HTML? What sorcery is this?”

And so began my journey into the magical, mildly chaotic world of React — a library that promises reactivity but comes with a fair bit of emotional damage if you're not ready.

But amidst the madness, I met the three pillars — the Big Dogs — that rule the React Kingdom:

1. Components – The React Royalty

Components are the DNA of every React app.
They’re like jenga pieces — reusable, stackable, occasionally painful when they come crashing down.

There are two kinds:

• Functional components (the modern cool kids; fast and flashy)
• Class components (the boomers React is slowly retiring with dignity)

Components let you split the UI into independent, self-contained pieces. Think of them like the Nigerian sandwich: agege bread becomes sliced, akara slid in between— heaven!

You build them, reuse them, and if you're really fancy, nest them deeper than your emotional trauma.
React doesn’t judge. Nest away.

2. Props – The Couriers of Truth

Next, I met Props — short for properties, but I call them "React amebo (gossip)".

Why? Because props are how one component tells another:
“Hey, here's everything you need to know. Don’t mess it up.”

Props are read-only, like the typical Nigerian mother who lectures you about life but won’t let you respond.

You pass them down from parent to child, which is super wholesome… until you’re 12 components deep and still passing the same prop like a relay baton from Mount Doom. That’s when you learn about context, but we’ll save that for the next therapy session.

Still, props are vital. Without them, your components are just pretty faces with no personality.
With them, they talk, interact, and become a full-blown React house of commotion.

3. Hooks – The Dark Arts of Functionality

And then came the one that changed my life: Hooks.

Hooks are like React’s secret spellbook. They let functional components do what only class components could do back in the day — things like managing state, side effects, refs, and existential crises.

The big ones:

• useState: for toggling between light/dark mode… or stable/losing your mind.
• useEffect: for running side effects — i.e., everything you were doing wrong before you learned this hook.
• useRef, useContext, useReducer… each with their own drama.

But here's the deal:
Hooks hook you. One minute you're writing a simple state update. The next, you're neck-deep in a custom hook that controls API calls, scroll behavior, and the emotional well-being of your users.

Once you go hooks, you don’t go back.
Unless you're debugging — in which case, you absolutely go back and cry.

Final Thoughts: The Trinity That Builds React Apps

React isn’t just a tool. It’s a lifestyle.
It teaches you component-based architecture, prop-drilling etiquette, and how to manage your emotional state with useState.

It humbles you with bugs like:

• “Maximum update depth exceeded”
• “Too many re-renders”
• And the classic: “Cannot read property ‘something’ of undefined”

But once you get it… oh man, it’s beautiful.
You start thinking in components.
You build like a UI poet.
You refactor with the confidence of a thousand console.logs.

So if you’re new to React, or if you’re still stuck in a toxic relationship with class components — take a breath.
Learn the Big Three: Components, Props, and Hooks.
Master them. Unhook them. Respect them. Laugh through the bugs.

Because once you do, React becomes more than a library.
It becomes your superpower.

Once upon a debug session…

I didn’t start out in a fancy bootcamp. There were no MacBooks on ergonomic standing desks, no curated coffee breaks or tech mentors in branded hoodies. Just me, a second-year Civil Engineering student juggling trusses by day and JavaScript by night — and a part-time gig as a video editor trying to make Adobe Premiere not crash every 5 minutes. Romantic, right?

But somehow, I fell into the rabbit hole of web development. It started with curiosity, evolved into obsession, and very quickly spiraled into an existential crisis involving semicolons and missing brackets. There were nights I stared at my VSCode terminal like it had personally wronged me. Spoiler alert: it had.

Back then, there was no ChatGPT. No friendly AI assistant to tell me, “Hey, you missed a closing tag.” No Copilot whispering sweet syntaxes into my editor. Just Stack Overflow, dense documentation, and a whole lot of Ctrl+Z. It was me, a barely-functioning laptop, the hum of a standing fan, and the creeping fear that I might never make it out of the tutorial hell.

And the errors. Oh, the errors. The “undefined is not a function” that defined my sleepless nights. The “cannot read property of null” that made me question my life's direction. There were moments I was sure I’d invented a new language entirely — one made up exclusively of bugs and broken dreams.

But I kept pushing.

Each commit was more than just code — it was a digital timestamp of struggle and small victories. A line of hope. A marker that said, “I was here, I broke it, and I fixed it… eventually.”

Some commits were angry — “Fix stupid bug AGAIN.”
Others were desperate — “Final_final_REALLY_FINAL_version2.”
But many, in hindsight, were beautiful, because they showed growth — not just as a developer, but as a person learning to fail, recover, and ship anyway.

There were days I felt like a fraud. Days I almost gave up. Nights I paced around my boxed little room like a mad scientist, whispering to myself, “Why won’t this damn API call work?”

But through the chaos — gracefully and God-fidently (yes, that’s God + confidence, deal with it) — I made it through. And I’m proud to finally say:
I’m a Full-Stack Developer.

Now, I want to tell my story.
Not just the shiny parts where the website loads and the animations are smooth.
But the messy commits. The tear-soaked bug hunts. The near-breakdowns.
The real journey behind every git push origin main.

So if you're out there, stuck on an error that makes no sense, or wondering if you'll ever “get it” — trust me, I’ve been there. And I survived. With hair loss, sleepless nights, and a Git history full of emotion.

Welcome to my journey. Let’s code and cry together.