All roadmaps

Node.js

JavaScript on the server, done seriously.

Node in depth: the runtime and event loop, core modules and streams, Express APIs, auth and security, databases, testing, and deploying services that survive production.

Your progress0/46 topics · 0%

Progress is saved in this browser.

6 stages46 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.

Node.js in 2026Related roadmapsJavaScript roadmapBackend roadmapAPI Design roadmapProve it as you goReading is half of it. This roadmap isbacked by a free, scored Node.jscertification with a public verificationlink and a Backend 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 thesyntaxNode.js in 2026What to learn in 2026Runtime, async,HTTPFrameworks anddatabasesAI services on NodeWhich roles use itBackend andfull stackPlatform andtoolingFresher vs switcherWhat companies expectThe hiring barWhat interviewstestProof they verifyWhat gets you hiredA 90-day planProjects thatget readCertification and proofUnderstand what Node is andisn't good at.Runtime FundamentalsEvent loop & non-blocking IOModules: ESM & CommonJSnpm & scriptsCore modulesStreams & buffersDesign and implement HTTPservices.Building APIsExpress essentialsREST designThe framework landscapeValidationAuth: sessions & JWTSecurity hardeningPersist state and protect itwith tests.Data & QualitySQL from NodeMongoDB from NodeTesting APIsConfig & environmentsThe Node beneath the framework.Deeper RuntimeEventEmitter & custom eventsChild processes & workerthreadsCLI applicationsCreating & publishingpackagesDebugging & memoryServices that survive contactwith users.Production NodeError handling & loggingDeploymentPerformance basicsProve 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 5 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 Node.js 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

    Node.js in 2026

    2026

    Node.js is the most used web technology in the Stack Overflow 2025 survey at 49 percent of developers, the runtime behind most JavaScript and TypeScript backends, most developer tooling and most AI SDKs, and the server half of the full stack job. In 2026 it also runs the agents and model-backed services that products are adding. 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, Octoverse 2025, Postman's 2025 State of the API report and HackerRank's 2025 report.

    What to learn in 2026

    Learn the runtime - the event loop, streams, the module system, process and environment, error handling - then HTTP and a framework, databases and authentication, and the production skills of testing, logging, deployment and performance. Then the 2026 layer: building model-backed services on Node with the TypeScript AI SDKs. The sub-nodes order those three. Node's 49 percent share in the Stack Overflow 2025 survey and TypeScript's first place in Octoverse 2025 explain why typed Node is the common shape.

    Runtime, async, HTTP

    The runtime is the subject: the event loop and why blocking it is the classic Node mistake, promises and async functions, streams for anything large, the module system, environment variables and process signals, error handling that does not crash the process, and the built-in HTTP server before any framework. The Stack Overflow 2025 survey's 49 percent share for Node.js means interviews assume this knowledge; a candidate who can explain why a CPU-bound loop stalls every request understands Node. Learn with TypeScript from the start - Octoverse 2025 shows it is how Node is now written.

    Frameworks and databases

    On top of the runtime sits a job's daily stack: Express, Fastify, Nest or Hono for HTTP; Postgres through a typed query builder or ORM such as Prisma or Drizzle; authentication through a provider; validation with Zod; testing with Vitest; structured logging; a queue for background work; and deployment on a container, a serverless platform or the edge. The Stack Overflow 2025 survey puts PostgreSQL first among databases at 58 percent, and Postman's 2025 report finds 83 percent of organisations API-first - so the API contract, documented and versioned, is part of the skill, not an afterthought.

    AI services on Node

    AI

    Most model-backed features ship as a Node service: a typed SDK call with a server-side key, a spending cap, structured output validated with a schema, streaming to the client, retries and a fallback, and logs that record cost. The AI SDKs from the major providers and the agent frameworks are TypeScript first, which Octoverse 2025 ties to TypeScript's rise. Gartner expects a third of enterprise applications to include agentic AI by 2028, and Postman's 2025 report finds one in four developers already designing APIs for AI agents. A Node developer who can build that service safely is the one being hired for it.

    Which roles use it

    Node is the backend of choice for full stack teams, a common choice for API and backend roles at product companies, and the language of platform and tooling work - CLIs, build tools, serverless and edge functions. The sub-nodes name the backend and full stack roles, the platform and tooling roles, and the fresher and switcher routes.

    Backend and full stack

    Backend developer and full stack developer are the titles that hire for Node most: the first owns services and APIs, the second owns them plus the React front end. The Stack Overflow 2025 survey's most common developer type is full stack, and Node's 49 percent share makes it the common server half. Startups, SaaS companies, e-commerce and the global capability centres post these roles; product companies with large Java or Go estates still use Node for the web layer, tooling and edge functions.

    Platform and tooling

    Platform and tooling roles use Node to build what other developers use: CLIs, build and deployment tools, internal services, serverless functions, edge middleware and the SDKs around AI products. Octoverse 2025 notes that much of the AI tooling ecosystem is written in TypeScript on Node, which is why those teams hire Node developers who can publish a package, write a CLI and reason about performance. The DevOps and Git roadmaps cover the surrounding skills.

    Fresher vs switcher

    A fresher should deploy one Node API with a database and authentication before applying, because HackerRank's 2025 report found early-career hiring hit hardest with 74 percent of developers struggling to land a job, and a callable API is the most convincing proof. A switcher from frontend work has the language and should spend the time on the runtime, databases and deployment; a switcher from another backend language should map concepts and learn the event loop's differences. On this map freshers get the runtime basics filled and the advanced stages outlined; experienced learners get the reverse.

    What companies expect

    Companies expect a Node developer to build and run a service: a typed API on a real database, authentication, tests, logs, deployment and an understanding of what the event loop does under load. HackerRank's 2025 report says practical assessments are the standard. The sub-nodes cover the bar, the interview and what gets verified.

    The hiring bar

    The bar is a service you can run: typed, validated at the boundary, authenticated, tested on the critical path, logged, deployed, and understood under load - what happens when the event loop is blocked, the database is slow or a model call times out. The Work Trend Index found 66 percent of leaders would not hire without AI skills; for Node teams that means drafting with agents and reviewing every line that touches data, money or auth before it ships.

    What interviews test

    Expect a practical build or fix on a small Node service, often with an AI tool allowed; questions on the event loop, async patterns, streams, HTTP, SQL and indexing, authentication and error handling; a system design conversation sized to the company; and a walk through your deployed API. HackerRank's 2025 report says 66 percent of developers prefer real-world assessments and that they are the standard. The best answers describe a failure you handled - a leaked connection, a blocked loop, a retry storm - and what you changed.

    Proof they verify

    Reviewers call your API and read the repository: a public base URL with an OpenAPI page and a health endpoint, authentication, a database, tests, logs and a readme with the decisions. That beats any description; OneRoadmap's free Node.js certification with its public verification link beats a course badge; a note on where a model sits in your service with its cap and fallback is now a differentiator.

    What gets you hired

    A deployed Node API with a database and authentication, a readable typed repository, a verified certification and an honest account of how AI tools were used. 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 runtime and TypeScript on small programs, then an HTTP API without a framework. Month two: a framework, Postgres, authentication, validation, tests and deployment of one real API, built with an AI tool and reviewed by you. Month three: a queue or a cache where the project needs one, one model-backed endpoint with a spending cap and a fallback, logs and a dashboard, a readme with the decisions, the Node.js certification, and twenty targeted applications a week.

    Projects that get read

    Projects that get read are services under some load: an API with pagination, rate limits and caching on a public dataset; a booking or inventory service with concurrency handled; a webhook processor with a queue, retries and idempotency; a streaming model-backed endpoint with cost logging. Each has a live base URL, an OpenAPI page, tests and a readme on the failure modes. The World Economic Forum's Future of Jobs 2025 report puts software developers among the fastest-growing roles; a service on the 2026 stack, explained, is the evidence.

    Certification and proof

    Proof is what a reviewer can call and check: OneRoadmap's free Node.js certification with a public link, a GitHub profile with real commits, a running API and a written account of your AI workflow. Octoverse 2025 counts more than 180 million developers on GitHub; the Node developers who get replies are the ones with a URL that answers.

  2. 2. Understand what Node is and isn't good at.

    Runtime Fundamentals

    Understand what Node is and isn't good at.

    Time: about 1-2 weeks. Topics: Event loop & non-blocking IO · Modules: ESM & CommonJS · npm & scripts · Core modules · Streams & buffers.

    Event loop & non-blocking IO

    Optional on the Experienced track

    Why Node scales connections cheaply on one thread - and what CPU-bound work does to it.

    Modules: ESM & CommonJS

    Optional on the Experienced track

    import vs require, package.json 'type' and interop - the module system you'll debug eventually.

    npm & scripts

    Optional on the Experienced track

    Dependencies, lockfiles, semver and npx - the contract of every Node project.

    Core modules

    Optional on the Experienced track

    fs, path, http, os and events - the standard library that pays rent daily.

    Streams & buffers

    Optional on the Experienced track

    Processing data bigger than memory: readable/writable streams, piping and backpressure at concept level.

  3. 3. Design and implement HTTP services.

    Building APIs

    Design and implement HTTP services.

    Time: about 2-3 weeks. Topics: Express essentials · REST design · The framework landscape · Validation · Auth: sessions & JWT · Security hardening.

    Build: REST API with auth. A documented CRUD API with registration, login, validation and protected routes.

    Express essentials

    Routing, middleware chains and centralised error handling - the request pipeline as one coherent design.

    REST design

    Resources, verbs, status codes and pagination - APIs a stranger can navigate without a meeting.

    The framework landscape

    Fastify for speed, NestJS for structure, Hono for the edge - Express concepts transfer; know when each alternative earns its keep.

    Validation

    Schema-validating every input at the boundary (zod/joi) - the cheapest security and quality win.

    Auth: sessions & JWT

    bcrypt hashing, token vs session trade-offs, refresh flows and protected routes.

    Security hardening

    CORS, rate limiting, helmet headers and injection defence - the OWASP basics wired into middleware.

  4. 4. Persist state and protect it with tests.

    Data & Quality

    Persist state and protect it with tests.

    Time: about 2-3 weeks. Topics: SQL from Node · MongoDB from Node · Testing APIs · Config & environments.

    SQL from Node

    Postgres with pooling, parameterised queries and transactions - or Prisma when an ORM earns its keep.

    MongoDB from Node

    Mongoose schemas, queries and aggregation - document modelling with guardrails.

    Testing APIs

    Vitest/Jest + supertest: unit tests for logic, integration tests for endpoints - confidence to refactor.

    Config & environments

    env vars, secrets and twelve-factor structure - one build, many environments.

  5. 5. The Node beneath the framework.

    Deeper Runtime

    The Node beneath the framework.

    Time: about 1-2 weeks. Topics: EventEmitter & custom events · Child processes & worker threads · CLI applications · Creating & publishing packages · Debugging & memory.

    EventEmitter & custom events

    The observer pattern at Node's core - how streams, servers and your own decoupled modules communicate.

    Child processes & worker threads

    Shelling out, spawning workers and clustering - escaping the single thread for CPU-bound work.

    CLI applications

    argv parsing (commander), prompts (inquirer) and exit codes - Node as a tool-building platform, not just a server.

    Creating & publishing packages

    package.json exports, semver discipline and npm publish - shipping reusable code to the registry.

    Debugging & memory

    --inspect with DevTools, heap snapshots and spotting leaks - evidence-driven debugging under load.

  6. 6. Services that survive contact with users.

    Production Node

    Services that survive contact with users.

    Time: about 2 weeks. Topics: Error handling & logging · Deployment · Performance basics · Prove it.

    Error handling & logging

    Optional on the Fresher track

    Central error middleware, structured logs (pino) and not leaking stack traces to clients.

    Deployment

    Optional on the Fresher track

    Docker or a PaaS, health checks, graceful shutdown and process managers.

    Performance basics

    Optional on the Fresher track

    Profiling, avoiding event-loop blocking, and caching hot reads - measured, not guessed.

    Prove it

    Optional on the Fresher track

    Take the OneRoadmap Node.js certification - verified backend fundamentals.

Prove it as you go

Reading is half of it. This roadmap is backed by a free, scored Node.js certification with a public verification link and a Backend 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 5 stages as a sequential checklist with time estimates. Your marks are shared between the two views.

Frequently asked questions

What is Node.js used for in 2026?

APIs and backends for web products, the server half of full stack applications, serverless and edge functions, developer tooling, and increasingly the services that call AI models - the SDKs and agent frameworks are TypeScript first. The Stack Overflow 2025 survey has Node.js as the most used web technology at 49 percent of developers.

Do I need to know JavaScript well before Node?

Yes. Node is JavaScript on a server, and the parts that matter most - the event loop, promises and async functions, streams, modules and error handling - are language knowledge. A frontend developer has most of it; the new material is HTTP, databases, deployment and what happens under load.

Express, Fastify, Nest or Hono?

Any of them; the concepts are identical. Express is the most widely known and appears in most tutorials; Fastify and Hono are faster and lighter; Nest adds structure for larger teams. Learn HTTP with Node's built-in server first, then pick the framework your target employers use.

Node or Python for backend?

Node if you also work on the front end or want one language across the stack; Python if you are heading toward data or AI engineering. Both are common at startups and product companies; Java and Go dominate enterprise and infrastructure. The runtime concepts transfer, so the second one is a month.

How long does it take to become job-ready?

A developer who knows JavaScript can deploy a real API with a database, authentication and tests in a few months of steady work; a beginner should add the JavaScript roadmap first. Nobody can promise a timeline. Readiness is an API a reviewer can call and a repository they can read.

Do I have to pay for hosting to learn this?

No. Free tiers on Vercel, Railway, Render, Supabase and Neon cover a learning project, and model providers offer small free allowances for an AI feature. Set a spending limit in every console and keep the project small until it needs to grow.

Will AI replace Node developers?

AI tools draft Node services quickly and get the event loop, error handling and security wrong in ways that only show under load. The engineer who understands why a blocked loop stalls every request, bounds a model call and reviews what touches data, money and authentication is the one those tools make more valuable.

How do I prove Node skills without job experience?

A deployed API with a public OpenAPI page, authentication, a database, tests, structured logs and a readme on the failure modes; one model-backed endpoint with a spending cap and a fallback; a GitHub profile with real history; and OneRoadmap's free Node.js certification with its public verification link. A URL that answers beats any description.