DEV Community: Paul Ifeoluwa-Levites

WHY 90% OF DEVELOPERS FAIL AFTER 6 MONTHS!!!

Paul Ifeoluwa-Levites — Sat, 18 Apr 2026 10:15:02 +0000

Most people don’t fail at programming because it’s too hard, they fail because they misunderstand what it actually takes.

Every year, thousands of beginners start their journey into tech. They watch tutorials, build a few small projects, maybe even feel confident after recreating a landing page or cloning an app. For a moment, it feels like they’re on track.

Then somewhere around the 3 to 6 month mark, everything changes, Progress slows down, Motivation drops, Tutorials stop making sense, Imposter syndrome kicks in.
And quietly, without any formal decision, they stop coding.
Not because they’re not smart, not because they lack talent, but because they fell into traps that almost every beginner walks into without even realizing it.

This isn’t another “just keep pushing” article, This is a breakdown of the real reasons why 90% of developers quit within their first 6 months and what the remaining 10% do differently.

If you’re learning to code right now, this might be the most important thing you read this year.

The Psychological Wall

Most aspiring developers don’t quit because code is hard; they quit because their brains literally hit a limit.

In the beginning, everything feels linear:

Learn HTML
Add some CSS
Sprinkle JavaScript

You see results instantly. Change a line, refresh the browser, and boom, you get instant feedback and result.

But then you move beyond basics, and suddenly you’re dealing with:

State management
Async logic
APIs
Framework abstractions And everything stops being visual and starts becoming mental.

This is the exact moment cognitive overload kicks in.
Your brain, which was comfortably processing simple patterns, is now forced to juggle multiple layers of abstraction at once:

What is happening?
Where is it happening?
When is it happening?
Why is it happening?

That’s not just learning anymore, that’s systems thinking.
And if you’re not prepared for it, excitement turns into frustration… fast.

If you’ve ever thought:
“I understood HTML and CSS, but now I feel completely lost…”
You are not untalented.
This is you experiencing a predictable psychological collapse that happens to almost every self-taught developer.

The Hard Truth

Here’s what no one tells beginners:
You cannot memorize your way into becoming a developer.
And yet, that’s exactly what most people try to do.

They:

Memorize syntax
Copy tutorials
Rebuild projects step-by-step

It works at first, but programming is not about remembering what to type, it’s about understanding why things work.

And that difference becomes painfully obvious around the 6-month mark.
At that point, the game changes:

Problems are no longer familiar
Solutions aren’t in your recent memory
Documentation feels overwhelming
Tutorials stop being enough

So what do most people do?
They double down on memorization.

They try harder.
Watch more tutorials.
Copy more code. And eventually… They drown!!!

The Real Transition Nobody Talks About

There’s a hidden shift every developer must go through:
Phase 1: Concrete Learning

HTML tags
CSS properties
Basic JavaScript Everything is tangible and visible.

Phase 2: Abstract Thinking

State
Data flow
Architecture
Debugging logic

Now you’re no longer just writing code, You’re managing complexity.

This is where most people quit, not because they can’t learn it, but because no one prepared them for the shift.
It feels like going from simple arithmetic to solving puzzles with missing pieces.

The Valley of Abandonment

This phase has a name:
The Valley of Abandonment.
It’s the point where:
You know too much to feel like a beginner, but not enough to feel competent.
You’re stuck in between, and it’s uncomfortable.

At this point, you:

Start doubting yourself
Compare yourself to others
Feel like you’re falling behind

This is where 90% of developers stop, not because they failed.
But because they misinterpreted the struggle as a sign that they should stop.

What the Top 10% Do Differently

The developers who make it past 6 months don’t have superpowers.
They just approach learning differently.

1. They Stop Memorizing — They Start Understanding
Instead of asking:
“What code should I write?”

They ask:
“What is actually happening here?”

They focus on:

Data flow
Cause and effect
How pieces connect

2. They Build Without Tutorials
Beginners rely heavily on guidance, while top learners deliberately struggle.

They:

Try projects without step-by-step help
Get stuck
Debug
Learn through failure That struggle is where real growth happens.

3. They Accept Confusion as Part of the Process
Most people quit because confusion feels like failure.
But the truth is, Confusion is a sign you’re leveling up.
If everything makes sense all the time, you’re not growing.

4. They Think in Systems, Not Lines of Code
Instead of focusing on syntax, they focus on:

Inputs → Process → Output
How components interact
How state changes over time

This is what separates coders from developers.

How to Survive the First 6 Months

If you’re currently in that frustrating phase, here’s what you should do:

Slow down. Depth beats speed.
Rebuild small projects from memory
Break problems into tiny pieces
Focus on why, not just how
Accept that struggle is required

Most importantly:
Don’t quit at the exact moment things start getting real.

Final Thoughts

The 6-month mark isn’t where developers fail, It’s where the real journey begins.
The ones who quit see difficulty as a stop sign, while the ones who succeed see it as a transition.

So if you feel stuck right now, overwhelmed, or unsure of yourself…
Good! Be proud of yourself, cause that is where growth begins, you’re exactly where you’re supposed to be.

The only question left is:
Will you push through the wall… or turn back like the 90%?

[Boost]

Paul Ifeoluwa-Levites — Tue, 25 Nov 2025 16:01:59 +0000

Understanding How the Internet Works: A Beginner's Guide to the Client-Server Model and APIs

Paul Ifeoluwa-Levites ・ Nov 25

#networking #api #beginners #architecture

Understanding How the Internet Works: A Beginner's Guide to the Client-Server Model and APIs

Paul Ifeoluwa-Levites — Tue, 25 Nov 2025 12:53:55 +0000

Ever wondered what happens behind the scenes every time you click a link?
Or what happens when you click a video on YouTube to watch? Or that picture on Facebook?

In this article, we will decisively break down every crucial concept you need to understand when fetching data from the internet. Prepare to gain a clear and comprehensive understanding of the key elements that drive this essential process.

WHAT IS THE INTERNET?

The internet is like a giant network of computers all over the world that are connected and constantly sharing information with each other.

Imagine it like a huge system of roads and highways. Just like cars travel on roads to reach different destinations, data (like messages, videos, websites) travels through the internet to reach your device, whether it's a phone, computer, or tablet.

You may not think about it, but from the moment you wake up and check your phone to the moment you fall asleep scrolling through social media, the internet is working behind the scenes, connecting, delivering, and powering almost everything you do.

Here are some everyday activities that rely on this massive network of connected devices called the internet:

Sending a WhatsApp message
Loading videos on TikTok or YouTube
Refreshing your Instagram feed
Checking your email
Playing online games
Using Google Maps
Shopping online

All of these are powered by the client–server model, which is the foundation of how the internet works.

THE CLIENT–SERVER MODEL (THE INTERNET’S BACKBONE)

At the core of almost everything you do online is a powerful concept called the client–server model.

CLIENT (Your Device)

A client is any device that requests information from the internet.
This includes:

Phones
Laptops
Tablets
Browsers (Chrome, Safari)
Apps (Instagram, YouTube, Facebook)

SERVER (Where the Data Lives)

A server is a special, powerful computer somewhere in the world that stores data and sends it back when requested.

Servers store things like:

Website files
Videos
Images
User data
Application logic

WHAT EXACTLY HAPPENS WHEN YOU CLICK A LINK?

Let’s break it down into a simple flow:

You click a link https://paullevitesofficial.vercel.app.
Your device sends a request through the internet.
The request reaches the correct server hosting that website.
The server processes the request and prepares the data (HTML, CSS, images, and so on).
The server sends the data back to your device.
Your browser displays the result.

This interaction is the foundation of the modern web.

HOW DO DEVICES “REQUEST” INFORMATION? (HTTP & HTTPS)

The internet uses a language called HTTP (HyperText Transfer Protocol).
This protocol defines how clients request data and how servers respond.

When a request is secure and encrypted, it uses HTTPS (the “S” means secure).

For example:

Loading a website
Checking your dashboard
Logging into an app

All of these involve HTTP/HTTPS requests behind the scenes.

WHERE DO APIs COME IN?

Now that you understand clients and servers, let’s talk about APIs—the messengers of the internet.

WHAT IS AN API?

An API (Application Programming Interface) is a special set of rules that allows two software applications to talk to each other.

Think of it like:

A waiter in a restaurant
You (the client) ask for food
The kitchen (the server) prepares it
The waiter (API) delivers it

Real-life examples of APIs:

Weather apps fetching today’s forecast
Google Maps being integrated into other apps
Payment gateways (like Flutterwave or Paystack) handling transactions
Facebook or Google login buttons on websites
Apps fetching your feed, profile, messages, or notifications

Without APIs, apps wouldn’t be able to communicate with servers or share data.

APIs + CLIENT-SERVER MODEL: PUTTING IT ALL TOGETHER

Here’s how most modern apps work:

You open an app → client
The app sends a request → API
The API talks to the server → processes the request
The server returns data → API sends it back
Your app updates the screen → you see the result

This cycle happens repeatedly, every time you scroll, refresh, or interact with something online.

SO WHY DOES ALL THIS MATTER?

Understanding how the internet works gives you:

Better knowledge as a user
A strong foundation if you’re learning programming
A deeper understanding of how apps like Instagram, YouTube, and TikTok function
The ability to build websites, apps, and backend systems

Whether you’re a beginner programmer, a curious learner, or someone looking to understand the digital world better, this knowledge is a major first step.

Array.reverse() - What happens behind the scenes when reversing arrays in Javascript?

Paul Ifeoluwa-Levites — Wed, 02 Apr 2025 01:02:07 +0000

In this article, we will discuss what happens behind the scenes when reversing an array in Javascript.

Note: This article aims to help Javascript programmers and prepare computer science undergrads for future exams.

Before we proceed, you are expected to have a very good knowledge of Javascript Arrays.

How can we reverse an array in JavaScript?

Before we explain the steps involved in reversing an array, we need to create an array and then reverse it.

Take the code below as an example;

//Array of numbers
const fruits = ["Mango", "Orange", "Apple", "Pineapple", "Guava"];
const fruits2 = fruits.reverse()

The output of the code above will reverse the array, and you'll have the output below;

["Guava", "Pineapple", "Apple", "Orange", "Mango", ]

The array has been successfully reversed, but what happened is not as straightforward as it looks.
Why did the above array switch positions and what exactly made this happen?

How did the reversal happen?

The first thing you have to note is that the arrays didn't just magically switch places, what happened was that opposite indexes swapped positions after every iteration.

Let's say you have the array.

const fruits = ["Mango", "Orange", "Apple", "Pineapple", "Guava"];

The swapping creates a loop, and after every iteration, the indexes in the array get swapped.

Let's take a closer look at the following steps;

Iteration 1: The first element with an index of [0], takes the position of the last index of [4], and vice versa.
We now have;

const fruits = ["Guava", "Orange", "Apple", "Pineapple", "Mango"];

Iteration 2: The element with an index of [1], takes the position of the last index of [3], and vice versa.
We now have;

const fruits = ["Guava", "Pineapple", "Apple", "Orange", "Mango"];

Iteration 3: The element with the index of 2 remains the same since it's not going to get swapped with any other element.

This is how arrays are reversed in JavaScript, and with these techniques, you can manage your data effectively while avoiding unintended changes.