RizTech Academy logo
RizTech Academy

JavaScript Complete Foundation

The only language that runs in every browser. Learn it properly, including the parts that confuse everyone.

JavaScript has a reputation for being confusing, and some of that is deserved. Asynchronous behaviour, `this`, and closures trip up people who have already been writing it for a year.

This course confronts those directly rather than hoping you pick them up. You will understand why an API call returns undefined, why `this` changed, and what actually happens when the browser runs your script.

Everything is plain JavaScript. No framework. Learn React on top of shaky JavaScript and you will spend years confused about which one is misbehaving.

Who this is for

  • Beginners starting web development
  • Anyone who has copied JavaScript that works but does not know why
  • Students preparing for React or Node

What you need first

  • A computer and a modern browser
  • The Web UI Development Foundation course helps but is not required

Tools you will use

Node.js 22+VS CodeChrome DevTools

By the end you can

  • Write modern JavaScript with let, const, arrow functions and modules
  • Manipulate the DOM and handle events confidently
  • Explain closures, scope and `this` rather than avoiding them
  • Use promises and async/await without guessing
  • Fetch data from an API and render it
  • Write classes, throw and catch errors, and validate input with regular expressions
  • Format money, numbers and dates correctly for an Indian audience
  • Debug JavaScript in browser devtools
  • Build and deploy a complete browser application with no framework
Reference code

Stuck? Compare your work

The tiffin order tracker as the capstone builds it. Only module 10 has a checkpoint — the rest of the course is concepts, and publishing disconnected snippets invites copying exactly what the lesson asks you to type.

It is there for when you are stuck, not to start from. Type the code yourself first — copying it will teach you very little.

View on GitHub
Syllabus

12 modules, 58 lessons

Work through these in order. Each lesson is short enough to finish in one sitting and ends with something to build, not a quiz.

  1. 1

    Getting Started

    Where JavaScript runs and how to experiment with it.

    1. What JavaScript is, and where it runs15 min
    2. The console and browser devtools20 min
    3. Running JavaScript: script tags and Node20 min
  2. 2

    Language Basics

    Values, types and the quirks worth knowing early.

    1. var, let and const — and why var is retired25 min
    2. Types, coercion and the == versus === argument30 min
    3. Strings and template literals20 min
    4. Operators, conditions and truthiness25 min
    5. Loops and iteration20 min
  3. 3

    Functions, Scope and Closures

    The conceptual core of JavaScript. Get this right and everything else follows.

    1. Function declarations, expressions and arrow functions25 min
    2. Scope and hoisting25 min
    3. Closures, explained with a problem they solve30 min
    4. The this keyword, and why it keeps changing30 min
    5. Callbacks and higher-order functions25 min
  4. 4

    Objects and Arrays

    How data is shaped in JavaScript, and the methods you will use daily.

    1. Objects, properties and methods25 min
    2. Arrays and the methods worth memorising30 min
    3. map, filter and reduce30 min
    4. Destructuring and spread25 min
    5. Optional chaining and nullish coalescing20 min
    6. Map and Set, and when a plain object is wrong20 min
    7. JSON, parse and stringify20 min
  5. 5

    Classes and Errors

    Building your own types, and failing on purpose instead of by accident.

    1. Classes, constructors and methods30 min
    2. extends, super, and what a prototype really is30 min
    3. throw, try/catch, and your own Error types30 min
  6. 6

    Text, Numbers and Dates

    The data a real form actually contains — validated, counted and formatted correctly.

    1. Regular expressions, built up from a pincode30 min
    2. Numbers, floating point and formatting rupees25 min
    3. Dates, times and the IST trap25 min
  7. 7

    The DOM

    Making a page respond to a user.

    1. What the DOM actually is20 min
    2. Selecting and changing elements25 min
    3. Events and event listeners30 min
    4. Event delegation and bubbling25 min
    5. Working with forms and validation30 min
    6. localStorage, and why it is not a database20 min
    7. Practice: a to-do list with no framework45 min
  8. 8

    Asynchronous JavaScript

    The part everyone finds hard, taken slowly.

    1. Why JavaScript is asynchronous at all20 min
    2. Callbacks and how they got out of hand20 min
    3. Promises30 min
    4. async and await30 min
    5. Fetching data from an API30 min
    6. Handling errors in async code25 min
    7. Practice: building a live data page45 min
  9. 9

    Modules and Tooling

    Splitting code up and using the wider ecosystem.

    1. ES modules: import and export25 min
    2. npm and package.json25 min
    3. Debugging in devtools properly25 min
  10. 10

    Design Patterns in JavaScript

    The handful worth knowing in a language where closures and first-class functions make half of them disappear into one line.

    1. What a design pattern really is25 min
    2. The module pattern, and what closures replaced30 min
    3. Factories, and why JavaScript rarely needs a builder30 min
    4. Strategy, when a function is already the pattern30 min
    5. Observer, and the event system you already use30 min
    6. Patterns in the browser, and when not to use one25 min
  11. 11

    Best Practices: Code Others Can Read

    Naming, size, comments and review. The difference between somebody who can make it work and somebody worth hiring.

    1. Naming things, which is most of the job35 min
    2. How big is too big35 min
    3. Comments that say why, and JSDoc that earns its place25 min
    4. Equality, null, and failing fast35 min
    5. Reading code, and reviewing it without being unbearable30 min
  12. 12

    Capstone: a tiffin service order tracker

    This course's own project, built from nothing to deployed, using everything it covered.

    1. What we are building, and the rules it must follow20 min
    2. Building the interface and rendering from state45 min
    3. The data layer, and surviving a reload45 min
    4. Validation, accessibility and deploying it35 min
Previous courseJava Complete FoundationNext courseWeb UI Development Foundation

Learning this with a mentor is faster

Going through a course like this one is how you qualify for our six-month internship, for selected students, mostly from Pune. Clear the interview and you build real-world projects with my mentorship.

About the internshipAll courses