I Finally Took Git & GitHub Seriously — Here’s What Changed

Johnston Abubakar Kweku — Mon, 23 Mar 2026 05:54:29 +0000

I just completed the Learn Git & GitHub course on Scrimba, and I can confidently say this is one of the most impactful things I’ve done for my development workflow.

Why Version Control Actually Matters

For a long time, Git felt like one of those tools you “kind of know” but don’t fully understand.

But the truth is — version control is not optional.

It’s what allows you to:

Track every change in your codebase
Experiment without fear of breaking everything
Collaborate effectively with other developers
Roll back mistakes without panic

Without Git, you're basically coding without a safety net.

What Changed for Me

After going through the course, I noticed a shift in how I approach development:

I think in commits, not just code
I structure projects more intentionally
Debugging feels less chaotic because I can trace history
I’m more confident experimenting with new features

It’s one of those skills that doesn’t just add to your toolkit — it upgrades how you use everything else.

Why I Recommend Scrimba

What stood out to me was how hands-on the learning experience is.

Instead of passively watching videos, you’re:

Writing actual commands
Interacting with a live environment
Practicing concepts in real time

The lessons are also very comprehensive, covering both fundamentals and practical workflows you’ll actually use.

A Quick Note on Scrimba Pro

If you’re serious about improving quickly, Scrimba’s Pro subscription is worth checking out.

It gives you a more structured path and helps you stay consistent — which, honestly, is half the battle when learning anything in tech.

Final Thoughts

If you’re still “winging it” with Git or avoiding it altogether, I’d strongly recommend fixing that.

It’s one of the highest ROI skills you can learn as a developer.

If you want to try the course, here’s my referral link:
https://scrimba.com/?via=u4375fca

Would love to hear how others learned Git — was it structured, or just trial and error?

Turning My Gap Year Into a Developer Launchpad: Building Real Projects While Learning JavaScript

Johnston Abubakar Kweku — Tue, 03 Mar 2026 11:53:03 +0000

My gap year wasn’t a pause in my life. It became the most deliberate year of skill-building I’ve ever had. At first it felt like a setback, but I reframed it as an opportunity for structured growth.

Two years ago, I lost my mom. Since then, I’ve been living with my dad and sister. My sister is currently in her final year at university, so I decided to wait until she completes school before leaving home for mine. That meant I had time. Instead of drifting through it, I decided to design it.

I’ve always had an affinity for technology. I was curious about how systems work long before I understood what software engineering actually meant. When I decided to start web development, I was confused. I didn’t know the optimal path. I didn’t feel ready. But I started anyway.

I chose Django as my entry point and committed to building real systems instead of just finishing courses.

Building Instead of Waiting

My first serious projects were backend-heavy because I wanted to understand how applications function beneath the interface.

I built:

A pharmacy POS system with role-based access control (RBAC), handling both wholesale and retail logic.

A blog platform called SyntaxAndStories with authentication, CRUD operations, and an AJAX-powered chat feature.

BizChat, a chat application using Django email-based signup verification.

Smaller CRUD-focused systems like a notes app and a learning log to strengthen database modeling patterns.

Working on these projects forced me to understand:

Authentication and authorization flows

Model relationships and database normalization

Django’s request/response lifecycle

Template rendering vs dynamic updates

Version control discipline with Git

Debugging became my primary learning mechanism. Errors in migrations, mismatched querysets, CSRF failures in AJAX requests — those moments clarified concepts more than any tutorial.

Watching code builds familiarity. Shipping code builds competence.

Why I Added JavaScript After Django

Django gave me backend confidence, but modern applications are interactive. Static template rendering isn’t sufficient when building responsive user experiences.

If my long-term goal is to contribute to remote teams globally, I need full-stack fluency.

That’s why I started learning JavaScript seriously.

I focused on:

DOM manipulation

Event-driven logic

Asynchronous programming

Fetch API and AJAX workflows

Scope, closures, and execution context

Structured learning helped accelerate my understanding of core JavaScript mechanics before integrating them into production code. Platforms like Scrimba (https://scrimba.com/?via=community
) made it easier to experiment directly inside lessons and understand real-time behavior before applying it to my own applications.

But the goal wasn’t just to complete lessons. It was integration.

I implemented AJAX in SyntaxAndStories to update chat messages without full page reloads. Instead of refreshing templates, I returned JSON responses and dynamically updated the DOM. It reduced friction and improved user experience significantly.

As traffic grows, my plan is to transition that feature to WebSockets for real-time updates. I’m thinking ahead about scalability even while building at a small scale.

What Building Real Projects Taught Me

Debugging is the real curriculum.
Understanding why something breaks is more valuable than copying a working solution.

Database design determines long-term flexibility.
Poor model planning creates refactoring debt.

UI matters more than backend developers initially assume.
Perceived performance affects user trust.

Shipping consistently beats chasing perfection.
Iteration creates momentum.

Learning in public creates proof.
Documentation and public repositories signal seriousness.

The Bigger Vision

This gap year is not idle time. It is a controlled build phase.

I code consistently. I refactor old projects. I improve UI with Tailwind. I integrate JavaScript intentionally instead of randomly adding features.

My goal is to become a developer capable of contributing remotely to teams across time zones — collaborating asynchronously, writing maintainable code, and shipping features that solve real problems.

What initially looked like a delay became my most focused period of technical growth.

I’m not waiting for opportunity. I’m preparing for it.