DEV Community: Johnston Abubakar Kweku

The African Developer Tax

Johnston Abubakar Kweku — Wed, 29 Apr 2026 16:23:41 +0000

Nobody talks about this enough.

Being a developer in Africa isn't just about writing code. There's an invisible tax you pay every single day that developers in other parts of the world don't think about.

The infrastructure tax
Your internet goes out in the middle of a deployment. Load shedding kills your machine mid-compile. You're debugging a production issue on mobile data because the power has been out for three hours. Meanwhile someone in San Francisco is complaining their office WiFi is slow.

You learn to code defensively. Save often. Work offline where possible. Commit frequently. Not because best practices told you to — because the environment demands it.

The payment tax
You want to buy a course. Pay for a domain. Subscribe to a tool that would make you 10x more productive. But your card doesn't work on Stripe. PayPal is restricted in your country. The workarounds cost more than the product.

You watch free tiers evaporate and can't upgrade. You learn to squeeze everything out of what's free because paid is not always an option.

The visibility tax
You build something real. Something good. But your network is small, your country doesn't trend on tech Twitter, and the algorithm wasn't built for you. Developers in other regions get featured, funded, and followed. You get ignored — not because the work is worse, but because the spotlight doesn't reach here.

The doubt tax
The most expensive one.

When every example you see doesn't look like you. When the success stories are always from the same cities, the same schools, the same backgrounds. You start to wonder if this path is really for you. If you're building toward something real or just running in place.

That doubt is not weakness. It's a rational response to a system that wasn't designed with you in mind.

But here's the thing
Every African developer who ships something — anything — has already cleared a bar that most people don't see. The finished product looks the same. The path to get there didn't.

That's not a consolation prize. That's a genuine edge. Resilience, resourcefulness, and the ability to build under constraint are skills. Hard-earned ones.

We're not behind. We're building on a harder difficulty setting.

And we're still shipping.

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.