The First 90 Days of Learning to Code: What to Expect

Everything is new. You write <h1>Hello World</h1> and it appears on your screen. You change the background colour with CSS and it works. You feel like a hacker in a movie.

HTML makes sense. Tags open and close. Attributes modify elements. The visual feedback is immediate: you type something, save the file, and see the result in your browser. Progress is tangible.

CSS is satisfying. You centre a div (eventually) and feel accomplished. You make text bigger, change colours, add borders. Your web page starts looking like a real website.

This phase feels great. You tell your friends you are learning to code. You imagine your future career. You are motivated.

What to do during this phase: Ride the wave. Build as many small things as you can while the energy is high. A personal page, a tribute page, a simple landing page. Push everything to GitHub. This early momentum creates a foundation you will draw on when things get harder.

Trap to avoid: Spending all your time customising your VS Code theme instead of writing code. Your editor looks pretty. Your skills have not improved. Write code.

JavaScript arrives. Variables are fine. Strings are fine. Numbers are fine. Then functions appear.

Functions break your brain. What is a parameter? What is an argument? What does "return" mean? Why does console.log inside a function behave differently than outside? You read the explanation three times and still do not get it.

Then arrays and array methods. .map(), .filter(), .reduce(). The tutorial makes it look easy. When you try to use them yourself, nothing works. You spend two hours on a problem that should take ten minutes.

This is the valley. Most aspiring developers quit here. Not because they are stupid. Because they expected the honeymoon to continue and the difficulty spike feels personal. It is not personal. Every person who has ever learned JavaScript went through this exact frustration.

What is actually happening: Your brain is building new mental models for abstract thinking. Programming requires a type of logic that is different from everyday thinking. Building these neural pathways takes time and repetition. The confusion is literally your brain rewiring itself.

What to do: Lower your expectations. Accept that you will be confused. Set a minimum: 30 minutes of coding daily, even when it feels pointless. Do coding exercises on freeCodeCamp or Codewars. Solve small problems. Small wins accumulate into confidence.

What not to do: Switch to a different language hoping it will be easier. Switch to a different tutorial. Conclude that coding is not for you. All of these are quitting in disguise.

Something shifts. You cannot always identify the exact moment, but around week six or seven, concepts that were confusing start making sense.

You write a function and it works on the first try. You use .filter() correctly without checking the documentation. You look at code you wrote in week two and see how messy it was. That recognition means you have grown.

The breakthroughs are not dramatic. They are quiet realisations. "Oh, so that is what a callback function is." "So the DOM is just the HTML page represented as a JavaScript object." "That is why we use async/await."

You start building slightly more complex things. A quiz with scoring. A todo app with local storage. A weather app that fetches data from an API. Each project is harder than the last, but the difficulty feels manageable rather than crushing.

What to do: Push through into building. This is the transition point from syntax learner to builder. Open a blank file. Do not follow a tutorial. Try to build something from memory and Google. The struggle is still there, but it is productive struggle now, not hopeless confusion.

A warning: Some people get addicted to tutorials at this point. They watch advanced tutorials because they can now understand them, which feels good. But understanding a tutorial is not the same as building independently. Resist the urge to consume more content. Build instead.

By week nine, if you have been consistent, you are a different person than the one who wrote "Hello World" on day one.

You can build a multi-page website from scratch. You can add JavaScript interactivity. You can fetch data from an API and display it on a page. You can use Git and GitHub without thinking about it. You can read error messages and actually understand what they mean.

You are not ready for a job yet. But you are ready to start learning a framework (React), which is the next major step. And because you understand vanilla JavaScript, React will make more sense to you than it does to someone who skipped the fundamentals.

Your GitHub has 8 to 15 small projects. Some are embarrassing. That is fine. They show progression. A recruiter who looks at your earliest project and your latest can see the improvement arc. That arc is impressive, even if the individual projects are simple.

Emotional state: A mix of confidence and impatience. You know more than you did, but you can see how much more there is to learn. This feeling never completely goes away. Senior developers feel it too. It is called growth.

Code at the same time every day. Morning, evening, during lunch, pick a slot and protect it. Consistency beats motivation. On the days you do not feel like coding (and there will be many), the habit carries you through.

Start with yesterday's problem. If you got stuck on something last night, start today's session with it. Your brain processes problems while you sleep. Solutions often appear after a break.

End each session with a small win. Fix a bug. Complete an exercise. Add a feature. Ending on a positive note makes it easier to start the next session.

Keep a log. Write three lines at the end of each day. What you learned. What you built. What confused you. On bad days, read the log from two weeks ago. You will see progress you cannot feel in the moment.

Join a community. A WhatsApp group, a Telegram channel, a bootcamp cohort, a study partner. Someone who asks "what did you build today?" creates accountability that solo learning lacks.

Celebrate the ugly projects. Your first calculator will look terrible. Your first website will be embarrassing. Push them to GitHub anyway. They are proof of effort. In six months, you will look back at them and laugh. That laughter is evidence of growth.

Day 90 is not a finish line. It is a checkpoint. You have survived the hardest part: the beginning. The rest is still hard, but in a different way. You are now building skills rather than building the foundation to build skills.

After day 90, your path typically looks like: Learn React (month 4), learn backend development with Node.js (month 5), learn databases and the African Stack (month 6), build portfolio projects and apply for work (month 7 onwards).

The emotional pattern repeats at each new stage. React has its own valley of confusion. Backend development has its own breakthrough moment. But each valley is shorter and each breakthrough comes faster because you have been through the cycle before. You know what confusion feels like, and you know it passes.

If you want guided support through these 90 days and beyond, McTaba Labs runs a 26-week marathon that covers everything from HTML basics to production M-Pesa integration. Mentors, code reviews, cohort accountability. KES 120,000 with M-Pesa instalment plans.

But whether you learn with us or on your own, the first 90 days are the same. Show up daily. Build things. Push through the valley. The breakthroughs will come.