All roadmaps

JavaScript

The language of the web, understood - not memorised.

JavaScript in depth: values and types, functions and closures, objects and prototypes, the DOM, the event loop and async, modules, error handling and modern tooling - with free resources on every topic.

Your progress0/52 topics · 0%

Progress is saved in this browser.

8 stages52 topics₹0 to follow

Filled nodes are the focus for this track; outlined ones can wait. Tap a topic to open it and mark it done, learning or skipped.

JavaScript in 2026Related roadmapsTypeScript roadmapReact roadmapNode.js roadmapFrontend roadmapProve it as you goReading is half of it. This roadmap isbacked by a free, scored JavaScriptcertification with a public verificationlink and a Frontend Engineer jobsimulation on real tickets - evidence arecruiter can check, not a claim. Marktopics done, learning or skipped as yougo; your progress carries into theclassic view.Get certified - freeJob simulationClassic viewKnow the demand before thesyntaxJavaScript in 2026What to learn in 2026The language,not jQueryAsync, modules,toolingAI-assisted JavaScriptWhich roles use itFrontend, Nodeor bothFresher vsswitcherWhere JS jobs areWhat companies expectThe hiring barWhat interviewstestProof they verifyWhat gets you hiredA 90-day planProjects thatget readCertification and proofSolid ground: syntax, values,control flow.Language BasicsVariables & scopeTypes & coercionControl flowStrings & template literalsMaster the heart of thelanguage.Functions & ClosuresFunctions in depthClosuresHigher-order functionsRecursionUnderstand what class syntaxsugars over.Objects & PrototypesObjects & property accessthis bindingPrototypes & inheritanceMaps, Sets & iterationprotocolsMake pages interactive withouta framework.The BrowserDOM selection & mutationEventsForms from JSStorage & browser APIsHandle time, network andfailure gracefully.Async JavaScriptThe event loopPromisesasync/awaitfetch in practiceThe runtime knowledge seniorsprobe for.Under the HoodClasses & OOP syntaxMemory & garbage collectionDebugging techniquesWork like it's a professionalcodebase.Modern JS & ToolingES modulesError handling patternsnpm & scriptsLinting, formatting & afirst testProve itFresher or experienced?Both tracks hold every topic. On the Fresher track thefoundations are filled and the later stages are outlined - dothem when a project needs them. On the Experienced track thefoundations are outlined and the later stages are filled. The2026 section at the top applies to both.Prefer a list?The classic view shows the same 7 stages as a sequentialchecklist with time estimates. Your marks are shared betweenthe two views.Open the classic view

Everything on this roadmap

Every stage and topic on the map, in reading order. Click any topic to open it.

The JavaScript roadmap, topic by topic

Every topic on the map in reading order, with what to learn and the resources we recommend. Main topics are open; open any subtopic to read it. Select a topic name to open it in the topic panel, where you can track your progress.

  1. 1. Know the demand before the syntax

    JavaScript in 2026

    2026

    JavaScript is the language of the browser, of Node on the server and of most of the code AI tools generate for the web, which is why it has topped the Stack Overflow survey for thirteen years running. In 2026 the question is no longer whether to learn it but how deeply, and what to add to it - TypeScript, a framework, and the habit of reviewing generated code. The four nodes answer what to learn, which roles use it, what companies expect and what gets you hired, with figures from the Stack Overflow 2025 survey, GitHub's Octoverse 2025, the State of JavaScript 2025 survey and the Work Trend Index.

    What to learn in 2026

    Learn the language itself - values, scope, closures, prototypes, the event loop, promises and async, modules and errors - before any framework, because that is what every interview probes and what you need to read generated code. The Stack Overflow 2025 survey has JavaScript used by 66 percent of developers, more than any other language; Octoverse 2025 shows TypeScript, its typed superset, becoming the most used language on GitHub in 2025. The sub-nodes order the language, the ecosystem and the AI-assisted way of working with both.

    The language, not jQuery

    The language is the job: let and const, types and coercion, functions, closures and this, objects and prototypes, classes, destructuring, iteration, modules, promises, async and await, the event loop, error handling and the DOM. The Stack Overflow 2025 survey puts JavaScript at 66 percent of developers, first for the thirteenth year, and the questions in a 2026 interview are the same ones from 2016: why does this change in an arrow function, what does the event loop do with a resolved promise, why is equality with two equals signs dangerous. Learn those from the specification's behaviour, not from a framework's abstraction over it.

    Async, modules, tooling

    Beyond the language sits the ecosystem a job uses daily: asynchronous patterns with fetch and streams, ES modules, npm and package management, a bundler or Vite, testing with Vitest or Jest, linting and formatting, and TypeScript, which the Octoverse 2025 report shows overtook JavaScript itself as the most used language on GitHub in August 2025 as AI tools made typed code the default. The State of JavaScript 2025 survey has React used by about 84 percent of JavaScript developers and the Stack Overflow 2025 survey has Node.js at 49 percent, so a framework and a runtime come next - after the language, never instead of it.

    AI-assisted JavaScript

    AI

    AI tools write JavaScript fluently and wrongly in the same breath: a missing await, a mutated prop, an unhandled rejection, a quietly broken equality. The Stack Overflow 2025 survey finds 80 percent of developers using AI tools, 46 percent distrusting their accuracy and only about 3 percent highly trusting it; GitHub reports 80 percent of new developers using Copilot in their first week. The skill employers are paying for is reading generated JavaScript faster than it was written: know the language well enough to see the bug in a draft, write the test that catches it, and own the change.

    Which roles use it

    JavaScript is the entry point to three families of jobs: frontend, Node backend and full stack, plus the mobile and desktop work that React Native and Electron make possible. The sub-nodes name the roles, separate the fresher route from the switcher's, and say where JavaScript jobs are by sector and city.

    Frontend, Node or both

    Frontend developers use JavaScript in the browser with React or another framework; Node developers use it on the server for APIs and services; full stack developers do both, and the Stack Overflow 2025 survey's most common developer type is full stack. React Native takes the same language to iOS and Android, Electron to desktop, and serverless functions to the edge. Every one of these starts with the language on this map; the framework choice comes from the job you want, so read the Frontend and Node.js roadmaps before choosing a direction.

    Fresher vs switcher

    A fresher's best proof is a deployed project where every line can be explained; HackerRank's 2025 report found early-career hiring hit hardest, with 74 percent of developers calling the job search a struggle, so explainable work is the differentiator. A switcher from design, QA, marketing or support should build in that domain with JavaScript. On this map freshers get the language basics filled and the advanced stages outlined; experienced learners get the reverse. Both should take TypeScript as the immediate next roadmap.

    Where JS jobs are

    JavaScript jobs are everywhere software is built for the web: product companies, e-commerce, fintech, media, agencies and the global capability centres that build products from India. Nasscom's 2026 review puts the Indian tech industry at 315 billion dollars with 59.5 lakh employees; Naukri's JobSpeak reported fresher hiring up 17 percent year on year in February 2026. Bengaluru, Hyderabad, Pune and Gurugram carry most roles, and remote roles for foreign companies pay in dollars for strong TypeScript and communication. Pay follows proof of shipping.

    What companies expect

    Companies expect JavaScript understood, not memorised: a candidate who can explain this, closures, coercion and the event loop, write modern asynchronous code, use TypeScript, and review what an AI tool generated. HackerRank's 2025 report says practical assessments are the standard. The sub-nodes cover the bar, the interview and the proof that gets verified.

    The hiring bar

    The bar is fluency: modern, asynchronous, typed JavaScript written and reviewed with confidence, in a framework the team uses, with tests where they matter. The Work Trend Index found 71 percent of leaders would prefer a less experienced candidate with AI skills over a more experienced one without, so using the tools is expected and explaining their output is the test. A candidate who can trace an async bug through a generated component is at the bar.

    What interviews test

    Expect language questions - closures, this, the event loop, promises, equality, prototypes - a small practical build or fix, often with an AI tool allowed, and a walk through your project. HackerRank's 2025 report says 66 percent of developers prefer real-world assessments and that they are now standard; product companies add an algorithms round in JavaScript, so arrays, strings, maps and recursion should be fluent in the language. The interviewer is listening for why, not just what.

    Proof they verify

    Hiring teams open the live link, read the code and check the credential. A deployed application with real asynchronous work - fetching, forms, state - beats a tutorial clone; a repository with readable commits beats an upload; OneRoadmap's free JavaScript certification with its public verification link beats a course badge. Add a short note on what AI generated and what you fixed; it is now part of the proof.

    What gets you hired

    A deployed project in the language, a repository that shows you understand the code in it, a verified certification and an honest account of your AI tool workflow. The sub-nodes give the ninety-day plan, the projects that get read and the proof that counts.

    A 90-day plan

    Month one: the language from values to async, with small deployed exercises and no framework. Month two: TypeScript plus React or Node, one deployed application with real data, built with an AI tool and reviewed by you. Month three: tests, a readme that explains the decisions and the generated parts you changed, the JavaScript certification, and twenty targeted applications a week. Freshers add algorithm practice in JavaScript; switchers add a project from their previous field.

    Projects that get read

    Projects that get read use the language's hard parts on purpose: a dashboard that fetches, caches and paginates a public API with error states; a form-heavy app with validation and keyboard accessibility; a small Node API with authentication and tests; a browser game or visualisation that shows the event loop and the DOM under control. Each needs a live link and a readme. The World Economic Forum's Future of Jobs 2025 report says 39 percent of skills change by 2030; a project on the 2026 toolchain is the proof you changed with them.

    Certification and proof

    Proof is verifiable: OneRoadmap's free JavaScript certification with a public link, a GitHub profile with real history, a live project and a written account of your AI workflow. Octoverse 2025 counts more than 180 million developers on GitHub with India the largest source of new ones; a profile that a reviewer can verify in a minute is the one that gets a reply.

  2. 2. Solid ground: syntax, values, control flow.

    Language Basics

    Solid ground: syntax, values, control flow.

    Time: about 1-2 weeks. Topics: Variables & scope · Types & coercion · Control flow · Strings & template literals.

    Variables & scope

    Optional on the Experienced track

    let/const vs var, block scope and hoisting - why old code behaves strangely and new code shouldn't.

    Types & coercion

    Optional on the Experienced track

    Primitives vs objects, == vs ===, truthiness and the coercion rules interviewers love to probe.

    Control flow

    Optional on the Experienced track

    Conditionals, loops, switch and early returns - plus the array methods that replace most loops.

    Strings & template literals

    Optional on the Experienced track

    Interpolation, common string methods and immutability - text handling you do every day.

  3. 3. Master the heart of the language.

    Functions & Closures

    Master the heart of the language.

    Time: about 2 weeks. Topics: Functions in depth · Closures · Higher-order functions · Recursion.

    Functions in depth

    Declarations vs expressions vs arrows, default and rest parameters - and how arrows change this.

    Closures

    Functions that remember their birthplace - the mechanism behind callbacks, privacy and most interview puzzles.

    Higher-order functions

    Functions that take and return functions - map/filter/reduce fluency and function composition.

    Recursion

    Base cases and call stacks - for tree-shaped data and a class of interview questions.

  4. 4. Understand what class syntax sugars over.

    Objects & Prototypes

    Understand what class syntax sugars over.

    Time: about 2 weeks. Topics: Objects & property access · this binding · Prototypes & inheritance · Maps, Sets & iteration protocols.

    Objects & property access

    Creation, destructuring, spread, optional chaining - the daily grammar of JS data.

    this binding

    The four binding rules (default, implicit, explicit, new) and how arrows opt out entirely.

    Prototypes & inheritance

    The prototype chain as delegation - property lookup, class syntax and what instanceof really checks.

    Maps, Sets & iteration protocols

    Beyond plain objects: keyed collections, iterables and for…of.

  5. 5. Make pages interactive without a framework.

    The Browser

    Make pages interactive without a framework.

    Time: about 2 weeks. Topics: DOM selection & mutation · Events · Forms from JS · Storage & browser APIs.

    DOM selection & mutation

    querySelector, creating and updating nodes, classList - the API frameworks wrap.

    Events

    Bubbling, capturing, delegation and preventDefault - the model behind every interaction.

    Forms from JS

    Reading values, validation and submission handling - the highest-stakes DOM work.

    Storage & browser APIs

    localStorage/sessionStorage, URL and History - platform features that remove dependencies.

  6. 6. Handle time, network and failure gracefully.

    Async JavaScript

    Handle time, network and failure gracefully.

    Time: about 2 weeks. Topics: The event loop · Promises · async/await · fetch in practice.

    Build: API-driven app, vanilla JS. A searchable, paginated UI over a public API with loading, empty and error states - no frameworks.

    The event loop

    Call stack, task queue and microtasks - why 'single-threaded' isn't the whole story, and what blocks it.

    Promises

    States, chaining, error propagation and combinators (all, race, allSettled).

    async/await

    Sequential-looking async code, try/catch error handling and parallelism pitfalls.

    fetch in practice

    Requests with loading, error, retry and abort - the 80% of real-world async work.

  7. 7. The runtime knowledge seniors probe for.

    Under the Hood

    The runtime knowledge seniors probe for.

    Time: about 1 week. Topics: Classes & OOP syntax · Memory & garbage collection · Debugging techniques.

    Classes & OOP syntax

    class, constructors, inheritance, getters and private fields - the modern syntax over the prototype machinery you already understand.

    Memory & garbage collection

    Reachability, common leak patterns (forgotten listeners, growing caches) and what WeakMap is actually for.

    Debugging techniques

    Breakpoints, watch expressions, the performance panel and console beyond console.log - evidence over guesswork.

  8. 8. Work like it's a professional codebase.

    Modern JS & Tooling

    Work like it's a professional codebase.

    Time: about 1-2 weeks. Topics: ES modules · Error handling patterns · npm & scripts · Linting, formatting & a first test · Prove it.

    ES modules

    Optional on the Fresher track

    import/export, module scope and how bundlers stitch files into apps.

    Error handling patterns

    Optional on the Fresher track

    throw, custom errors and where to catch - failing loudly in dev, gracefully in prod.

    npm & scripts

    Optional on the Fresher track

    package.json, semver and lockfiles - the contract of every JS project.

    Linting, formatting & a first test

    Optional on the Fresher track

    ESLint, Prettier and one Vitest test - automation that catches bugs before review.

    Prove it

    Optional on the Fresher track

    Take the OneRoadmap JavaScript certification - 10 minutes to verified proof.

Prove it as you go

Reading is half of it. This roadmap is backed by a free, scored JavaScript certification with a public verification link and a Frontend Engineer job simulation on real tickets - evidence a recruiter can check, not a claim. Mark topics done, learning or skipped as you go; your progress carries into the classic view.

Fresher or experienced?

Both tracks hold every topic. On the Fresher track the foundations are filled and the later stages are outlined - do them when a project needs them. On the Experienced track the foundations are outlined and the later stages are filled. The 2026 section at the top applies to both.

Prefer a list?

The classic view shows the same 7 stages as a sequential checklist with time estimates. Your marks are shared between the two views.

Frequently asked questions

Is JavaScript still worth learning in 2026?

Yes. It is the language of the browser, of Node on the server and of most of the code AI tools generate for the web, and it has topped the Stack Overflow survey for thirteen years. TypeScript, which now leads on GitHub, is JavaScript with types; learning the language properly is the prerequisite for both.

JavaScript or Python as a first language?

Pick by the work you want. JavaScript if you want to build for the web - interfaces, Node backends, full stack - because the browser runs nothing else. Python if you want data, AI or automation. Both are beginner-friendly and both have large job markets; the concepts transfer, so the second language is weeks once the first is understood.

Do I need to learn TypeScript?

Yes, soon after the basics. GitHub's Octoverse 2025 found TypeScript the most used language on GitHub, driven by AI tools that write typed code by default. Learn plain JavaScript first so you understand what the types describe, then add TypeScript before your first real project.

Which framework should I learn after JavaScript?

React for the browser and Node for the server, because they have the most jobs and are what AI builders generate. Learn the language first - closures, this, the event loop, promises - because every framework hides those and every interview asks about them.

How long does it take to learn JavaScript?

The basics take weeks; fluency with async code, the DOM and the parts interviews probe takes months of daily practice. Nobody can promise a timeline. Readiness is a deployed project in which you can explain every line, a verified certification and the ability to read code an AI tool generated and spot the bug.

Should I learn jQuery or older patterns?

No. Read them when you meet them in old codebases, but learn modern JavaScript: modules, fetch, async and await, classes, destructuring and the array methods. Interviews and new code in 2026 assume these; jQuery knowledge is history, not a skill.

Will AI replace JavaScript developers?

AI tools write JavaScript fluently and introduce the classic bugs - a missing await, an unhandled rejection, a mutated object - just as fluently. The skill employers pay for has shifted toward reading generated code quickly and knowing the language well enough to see what is wrong. That makes depth in the language more valuable, not less.

How do I prove JavaScript skills without job experience?

A deployed project that uses the hard parts on purpose - asynchronous data fetching with error states, forms with validation, a small Node API with tests - with a readme that explains it and a note on what an AI tool generated and what you fixed. Add OneRoadmap's free JavaScript certification, which carries a public verification link, and a GitHub profile with real history.