If I Had to Learn JavaScript Again: An 8-Year Journey Through Web Development

Web Development

An honest account of an 8-year self-taught journey in web development, from basic HTML/CSS to full-stack JavaScript, React, Node.js, and TypeScript, offering practical advice and a structured learning roadmap.

Fresh out of high school, without a clear plan or direction, I started my journey into web development with just a laptop and a vague idea of what to do with my life. Eight years later, I'm a full-stack developer building production applications with Node.js, React, and TypeScript.

However, the path to learning to code is rarely linear. It's often messy, filled with false starts, detours, moments of giving up, and triumphant comebacks. This is the real story of that journey. (Please note: some years might be approximate; the focus is on the learning process, not exact dates).

Today, I build impactful applications using Node.js, React, and TypeScript—technologies I couldn't even fathom back then.

The Beginning: HTML, CSS, and Pretending I Knew What I Was Doing (2017)

My coding journey began in 2017, immediately after high school. My first exposure was to HTML and CSS, not due to a grand plan, but because a random YouTube video suggested starting there.

I created some truly unsightly websites: blue backgrounds, pervasive Comic Sans, and oversized images that often broke the layout. Yet, they worked. I typed code, refreshed the browser, and saw my creations appear on screen. This immediate feedback was incredibly captivating.

I spent about a month simply experimenting with HTML and CSS. I built an (embarrassing) portfolio site, a (worse) fake restaurant menu, and attempted to replicate the Google homepage with spectacular failure.

Unbeknownst to me, I was building a crucial foundation: understanding how browsers function, structuring web pages, and effectively using search engines to troubleshoot errors. This underlying knowledge proved more vital than I realized.

Resources that genuinely helped:

  • W3Schools - Often criticized, but it's straightforward and effective for beginners.
  • MDN Web Docs - Every page was bookmarked; I still use it regularly.
  • CSS-Tricks - My go-to whenever my layouts inevitably broke.

Then came a wave of overconfidence: "HTML and CSS are easy, so programming will be too." I was wrong.

The School/University Years: Where Nothing Really Clicked (2017-2020)

The uncomfortable truth is that my formal education didn't impart much practical programming knowledge. We had computer science classes, where we "learned" about loops and variables, but nothing truly stuck because it never felt tangible.

Instructors would demonstrate pseudocode, we'd write Java on paper, take a test, pass, and promptly forget everything the next day.

Programming felt like memorizing abstract math formulas I'd never apply—boring and pointless.

I went through the motions, but the concepts remained elusive. I passed classes, but if asked to build anything, I'd have no idea where to begin.

Looking back, the issue wasn't an inability to learn; it was the absence of building anything meaningful. I was merely copying examples and regurgitating them for tests.

The Detour: CCNA and the Command Line Awakening (2018)

Around 2018, I made an unexpected decision: I completely abandoned programming to pursue networking, specifically studying for the CCNA (Cisco Certified Network Associate) certification.

This might seem random, but it led to a breakthrough.

I was configuring routers and switches using Cisco's command-line interface. Commands like:

Router> enable
Router# configure terminal
Router(config)# interface fastethernet 0/0
Router(config-if)# ip address 192.168.1.1 255.255.255.0

Something clicked. The command line, the act of typing commands and observing immediate results, felt incredibly powerful. It was like direct communication with the machine, bypassing graphical interfaces.

I immersed myself in CCNA for 6-9 months, learning about networks, IP addresses, routing protocols, and VLANs. I became quite proficient.

However, a persistent thought lingered: "This is interesting, but I want to build things, not just configure them."

Nevertheless, the command-line experience planted a crucial seed, sparking my curiosity about terminals, scripting, and automating tasks rather than clicking buttons.

The Real Start: Coming Back to Programming (Late 2018)

In late 2018, during a short break, I found myself contemplating whether to fully commit to coding after my CCNA experience.

I returned to programming with a different mindset, this time with a specific school project in mind.

After extensive research, I decided on a job posting system—an internal job board for companies to list openings and students to apply. I had absolutely no idea how to build it.

Navigating university life, I was simultaneously trying to establish a career and simply pass classes. Despite the uncertainty, I committed to building this project.

The School Project That Changed Everything: Job Portal

This job portal project was where everything finally connected.

I chose PHP because I found a tutorial that made it seem easy (it wasn't). I spent three months building it—not just after class, but through all-nighters, weekends, and by skipping social events due to my obsession.

The scope was ambitious for a beginner:

  • Companies could register and post jobs.
  • Students could create profiles and apply.
  • An admin panel to manage all aspects.
  • A MySQL database to store data.
  • A login/logout system with sessions.
  • File uploads for resumes and documents.

My friends thought I was insane: "Why are you doing so much? Just build something simple to pass the class." But I couldn't stop. I was hooked. This was my first time building something real, something people could actually use (even if it was just for a school project).

The code was a mess. I read countless articles. There were SQL injection vulnerabilities everywhere (I had no knowledge of security). It was probably 80% Stack Overflow copy-paste and 20% my own attempts to understand how it all fit together. But it worked.

Then I hit a wall: the site felt static and lifeless. Clicking a button would refresh the entire page, creating a clunky, outdated user experience.

That's when I discovered jQuery. I found a tutorial on adding animations and submitting forms without full page refreshes. I spent several more weeks learning AJAX, enabling dynamic updates without reloading the entire page.

Suddenly, the job portal came alive. Buttons animated on click, job listings loaded smoothly, and form validation happened in real-time.

When I presented it to my class, my friends were astonished. The teachers were confused, as it far exceeded their expectations. One teacher even questioned if I had copied it (I had copied parts, but I understood them, which truly mattered).

I earned an A, of course. More importantly, I had a profound realization:

This interactivity, this JavaScript magic, was what made websites feel modern. This was what I wanted to pursue.

The project is still on GitHub if you're curious about my early, messy code:

https://github.com/elvis-sautet/job-portal-system

Looking at it now makes me cringe a bit, but I'm also incredibly proud. That project transformed me into a developer.

JavaScript: When It Finally Made Sense

After the job portal, I was done with PHP. JavaScript was where the real magic happened, and I craved more.

I started learning JavaScript properly, not from structured courses, but by building. javascript.info became my bible—it's free, comprehensive, and treats you like an intelligent learner.

I delved into:

  • Variables (let, const, var—var still causes confusion, honestly)
  • Functions (understanding return values took ages)
  • Arrays and objects (my mind was blown when objects could contain functions)
  • DOM manipulation (getElementById became my closest ally)
  • Async JavaScript (callbacks, promises, async/await—this nearly broke my brain)

I built every project I could think of:

  • A calculator (naturally)
  • A To-Do app (built it about ten times)
  • An expense tracker (because I was constantly broke)
  • A random quote generator
  • A weather app using free APIs

The crucial difference this time? I was building things I genuinely wanted to use, not just following tutorial examples. These were my projects.

My grasp of JavaScript eventually led me to Node.js, with "The Net Ninja" channel significantly pushing me to understand its concepts.

YouTube channels that saved me:

  • The Net Ninja: Shaun's JavaScript playlist is legendary, explaining concepts conversationally rather than academically.
  • Web Dev Simplified: Kyle makes complex topics seem simple. His React hooks video finally demystified hooks for me after weeks of confusion.
  • Programming with Mosh: Mosh's teaching style is structured and clear, excellent for fundamentals.
  • Traversy Media: Brad's crash courses taught me more practical skills than any paid course.

Here's the trick I learned: watching isn't learning. I'd watch a video, pause it, attempt to build it myself without looking, break it, fix it. That's how the knowledge truly cemented.

I spent 6-8 hours a day coding, without exaggeration. Mornings, afternoons, evenings. My laptop became an extension of my body. My parents worried I was wasting my time, and my friends thought I was obsessed.

I was obsessed. And that obsession made all the difference.

React: The Framework That Almost Broke Me (Late 2021-2022)

Around late December 2021, React was ubiquitous. Job postings demanded it, and developers raved about it. So, I plunged in.

And I nearly quit coding entirely.

React made absolutely no sense for the first month. Components? Props? State? JSX that resembled HTML but wasn't? It was utterly baffling.

I tried learning it three separate times before it finally clicked:

  • First attempt: Watched a 10-hour course. Understood nothing. My brain hurt. I gave up.
  • Second attempt: Tried to build something. Spent a week battling errors. Gave up again.
  • Third attempt: Went back to basics. Read the React official docs slowly, one concept at a time. Built tiny examples. I refused to move forward until I fully understood each piece.

That's when it finally clicked: React isn't magic; it's simply JavaScript with a different approach to UI development.

My breakthrough project was a movie search app using the OMDB API. You could type a movie name, see results, and click for details. It was simple enough to complete yet complex enough to facilitate genuine learning.

Then, I did something that solidified my understanding: I rebuilt it from scratch without referring to any tutorials. That's when I knew I had truly learned it, not just copied it.

React resources that worked:

  • React official docs - Seriously, start here.
  • freeCodeCamp React tutorial (on their website) - Long but thorough.

I delved deeply into React. It clicked, though not perfectly. Concurrently, I explored Node.js in depth, secured local gigs, and built projects. By then, I was comfortable with React and Node, though certainly not a "GURU." I was somewhere in between.

TypeScript: The Boss Level (2023-2024)

By early 2024, TypeScript was everywhere. Job postings mandated it, and senior developers swore by it. It was time to level up.

"It's just JavaScript with types," they said. "Easy," they said.

They lied. TypeScript was incredibly frustrating.

Everything I wrote immediately threw errors. "Why is this breaking? It works fine in JavaScript!" became my daily lament into the void.

Then I discovered Matt Pocock.

Matt Pocock and his YouTube channel are the TypeScript wizards. His free tutorials on Total TypeScript changed everything.

He explains TypeScript in a practical, understandable way, avoiding academic jargon and excessive complexity.

TypeScript learning path that actually worked:

  • Matt Pocock's "TypeScript for Beginners" playlist on YouTube.
  • Free "Beginner's TypeScript Tutorial" on Total TypeScript.
  • TypeScript official docs - Excellent once you have a basic understanding.
  • Convert an existing JavaScript project to TypeScript (painful but highly educational).

TypeScript basics you actually need:

  • Type annotations for variables and functions.
  • Interfaces for objects.
  • Union types (the | operator).
  • Basic generics.
  • Utility types like Partial, Pick, Omit.

What you can skip at first:

  • Advanced generic tricks.
  • Mapped types.
  • Conditional types.
  • Declaration files.

Learn these later, when a real need arises. Don't overwhelm yourself initially.

The Things That Actually Made Me Better (The Real Lessons)

Let me skip the motivational clichés and tell you what actually propelled my skills forward:

1. Building Projects I Cared About

Stop building generic to-do apps. Build something you genuinely want to use.

I built:

  • A habit tracker (used it for a year).
  • A side project ideas manager (still use it).
  • A Chrome extension to block Twitter during work (significantly boosted my productivity).
  • A personal finance dashboard (helped me overcome financial struggles).

When you use your own creations, you inherently discover bugs, add features, and become invested in making them excellent.

2. Reading Other People's Code

I found small projects on GitHub, typically 500-1000 lines, and read through them entirely.

This taught me:

  • How real-world projects are structured.
  • Patterns I'd never encountered in tutorials.
  • More efficient ways to implement familiar concepts.
  • How to navigate a codebase effectively.

I read through 30-40 projects and learned more from that experience than from any course.

3. Deploying Everything

Built something? Deploy it. It doesn't matter if it's imperfect or buggy. Put it online.

  • Vercel for frontend - Free, takes minutes.
  • Railway for full-stack - Replaced Heroku for me.
  • Netlify for static sites - Also free.

Having real, accessible projects online is far more valuable than keeping them forever on localhost.

4. Writing About What I Learned

Around 2022, I started writing on DEV.to. I penned short posts about concepts I had figured out.

Writing forces you to truly understand a topic. Additionally, people often comment with alternative or better solutions, providing another valuable learning avenue.

5. Hours. Stupid Amounts of Hours.

There are no shortcuts. I consistently spent 6-8 hours a day coding, sometimes more, including weekends, early mornings, and late nights.

This wasn't solely due to discipline; it was born from obsession. I couldn't stop thinking about the problems I was trying to solve.

If you lack this level of obsession, this journey will be exceptionally challenging. Find what makes you passionate about coding.

The Path I'd Take If Starting Fresh Today

Knowing everything I know now, here's the exact roadmap I would follow if I were starting from zero:

Months 1-2: HTML, CSS, JavaScript Basics

  • Week 1-2: HTML and CSS fundamentals.
    • W3Schools for basics.
    • Build 3 simple pages (e.g., portfolio, landing page, blog).
  • Week 3-6: JavaScript fundamentals.
    • javascript.info - Read sections on variables, functions, arrays, objects, loops, conditionals.
    • Build: a calculator, a simple grade book, a random quote generator.
    • NO frameworks. Stick to vanilla JavaScript.
  • Week 7-8: DOM manipulation.
    • Learn querySelector, addEventListener, innerHTML.
    • Build: a to-do app, a counter, a simple game (like Rock, Paper, Scissors).

Key Resources:

Months 3-4: Modern JavaScript + Async

  • ES6+ features: arrow functions, template literals, destructuring, spread/rest operators.
  • Promises and async/await.
  • Fetch API, working with external APIs.
  • Build: a weather app, a GitHub profile viewer, a movie search application.

Months 5-6: React

  • Do not touch React until your JavaScript knowledge is solid. Seriously.
  • When ready:
    • Complete the React official tutorial.
    • Build 3-4 small projects (your own ideas, not just tutorial copies).
    • Learn hooks deeply: useState, useEffect, useContext.

Months 7-8: Node.js and Backend

  • Express.js basics.
  • REST API concepts.
  • Database (MongoDB or PostgreSQL).
  • Authentication (JWT or sessions).
  • Build: A full-stack application (e.g., a more advanced to-do app, a simple blog, or a CRUD application).

Months 9-10: TypeScript

Months 11-12: Portfolio and Job Prep

  • Build 3-5 real-world projects.
  • Deploy everything.
  • Write about what you learned.
  • Practice interviews (a necessary evil).
  • Apply for jobs.

What to Skip Completely

  • Skip: Design patterns before you need them. Singleton, factory, observer—learn these when you encounter a problem they are designed to solve.
  • Skip: Multiple frameworks at once. Pick React OR Vue. Master one. Learn others if and when needed later.
  • Skip: Tutorial hell. If you've watched 3+ tutorials on the same topic, stop watching. Start building.
  • Skip: Certificates. No one has ever asked about my Udemy certificates. Build projects instead.
  • Skip: Perfectionism. Ship working code. Refactor later. Perfect code that never ships is worthless.

My Essential Resource Bookmarks

Learning Platforms & Documentation:

YouTube Channels:

For TypeScript Specifically:

Community & Practice:

Deployment Services:

The Uncomfortable Truths Nobody Tells You

It Takes Way Longer Than You Think

I'm 8 years into this journey (2017-2025) and still learning daily. You never truly "finish" learning; technology evolves too rapidly.

You'll Feel Stupid Constantly

Even now, I encounter code and think, "What is this?" That feeling of uncertainty never fully disappears. Get comfortable with not knowing everything.

Getting the First Job Is Brutal

I applied to over 100 jobs before landing my first one. However, once you gain that initial year of experience, the process becomes significantly easier.

Imposter Syndrome Is Real

I still occasionally Google "how to center a div." Senior developers also look up basic concepts. We're all continuously figuring things out.

You Don't Need to Know Everything

Master one stack. JavaScript, React, Node.js, and TypeScript are sufficient to get hired and build meaningful applications.

Where I Am Now (2025)

Today, I am a full-stack developer, working with Node.js, React, TypeScript, and PostgreSQL to build production applications that people actively use.

I am not a genius, nor a "10x engineer." I am simply someone who dedicated countless hours to writing code, breaking things, fixing them, and learning from mistakes.

The journey from those ugly HTML pages in 2017, through the CCNA detour, the PHP job portal project in 2020, to building production apps today, was anything but linear. It was messy, full of false starts, periods of quitting, and determined comebacks.

But I would do it all again. Perhaps I'd skip the CCNA year (though the command line experience was beneficial) and focus more on building practical projects earlier, spending less time trapped in "tutorial hell."

However, the core principles would remain the same: build things, ship them, break them, fix them, learn, and repeat.

If You're Starting Today

You are in a better position than I was in 2017. There are superior resources, better tools, and AI to assist with debugging (though don't rely on it entirely).

But the fundamentals are unchanged:

Spend hours writing code. Build projects you genuinely care about. Ship your work even when it's not perfect. Be comfortable with feeling lost, because that feeling never truly goes away.

Start with HTML and CSS. Then dive deep into JavaScript. Do not rush to frameworks.

Then React. Then Node.js. Then TypeScript.

One step at a time. One project at a time. One hour at a time.

In a few years, you'll look back and realize you've progressed further than you ever thought possible.

That's my story—the real one. No shortcuts, no overnight success, just 8 years of consistent effort, continuous learning, and many hours staring at error messages at 3 AM, wondering what went wrong.

If this resonated with you, please share it with someone who is learning to code. We all need authentic stories, not just highlight reels.