--- title: "Node.js Developer Beginner to Expert" description: "A roadmap for learning Node.js: the runtime and event loop, building APIs, databases, streams, testing, security, and production deployment." author: "Mohammad Abu Mattar" canonical: https://mkabumattar.com/roadmaps/post/nodejs-developer-roadmap --- # Node.js Developer Beginner to Expert This roadmap takes you from JavaScript foundations and the event loop through building APIs, working with databases, streams, testing, and security, and on to running Node in production. Go in order, build something small at each stage, and treat the optional topics as branches to explore once the required ones feel solid. ## Roadmap ### Stage 1: JavaScript Foundations Node is JavaScript on the server, so the language comes first. #### Modern JavaScript Learn ES modules, closures, promises, async/await, destructuring, and array methods. Most Node confusion is really async-JavaScript confusion. - [MDN JavaScript Guide](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide) #### TypeScript (recommended) _(recommended)_ Learn enough TypeScript to type functions, objects, and async code. Most serious Node codebases use it. ### Stage 2: The Node Runtime and Event Loop The mental model that everything else depends on. #### The event loop Understand how Node handles I/O with a single-threaded event loop, the phases, and the difference between the microtask and macrotask queues. - [Node.js event loop docs](https://nodejs.org/en/learn/asynchronous-work/event-loop-timers-and-nexttick) #### Blocking vs non-blocking Learn why CPU-heavy work blocks the loop and starves every other request, and what to do about it. #### Globals and process _(recommended)_ Get comfortable with process.env, argv, exit codes, and the module system (CommonJS vs ESM). ### Stage 3: Modules and npm How Node code is packaged and shared. #### package.json and semver Understand dependencies vs devDependencies, semantic version ranges, and lockfiles for reproducible installs. #### CommonJS vs ES Modules Know the difference between require and import, and how the package type field and file extensions affect module resolution. #### Publishing and scripts _(optional)_ Learn npm scripts and the basics of publishing a package. ### Stage 4: Core Built-in Modules What ships with Node before you add any dependency. #### fs, path, os Read and write files (sync vs async vs promises), build cross-platform paths, and query the system. #### http and events Create a raw HTTP server and understand the EventEmitter pattern that Node is built on. ### Stage 5: Building HTTP APIs The bread and butter of server-side Node. #### A framework (Express or Fastify) Learn routing, middleware, and request/response handling. Fastify adds schema validation and speed; Express is the ubiquitous default. - [Express docs](https://expressjs.com/) #### REST design Design clean resources, status codes, and error responses, and validate input at the boundary. #### Authentication _(recommended)_ Implement sessions or JWTs, hash passwords properly (bcrypt/argon2), and protect routes. ### Stage 6: Databases Persisting data from Node. #### SQL with an ORM/query builder Use Prisma, Drizzle, or Knex against PostgreSQL, and understand connection pooling. - [Prisma docs](https://www.prisma.io/docs) #### Migrations Version your schema so changes apply consistently across environments. #### NoSQL and caching _(optional)_ Know when a document store (MongoDB) or a cache (Redis) fits, and how to use them from Node. ### Stage 7: Asynchronous Patterns and Streams Going beyond simple request/response. #### Streams and backpressure _(recommended)_ Read and write large data with streams instead of buffering it all in memory, and understand backpressure. - [Node.js Streams docs](https://nodejs.org/en/learn/modules/how-to-use-streams) #### Error handling Handle rejected promises, uncaught exceptions, and graceful shutdown so one error does not crash or hang the process. ### Stage 8: Testing Confidence that your code works and keeps working. #### Unit and integration tests Write tests with the built-in node:test runner, Vitest, or Jest, and test your API against a real test database. #### Mocking and coverage _(recommended)_ Mock external services, and use coverage to find untested paths without chasing 100%. ### Stage 9: Security The essentials that keep a Node service safe. #### Common vulnerabilities Guard against injection, validate and sanitize input, set security headers (helmet), and manage secrets outside the code. #### Dependency hygiene _(recommended)_ Audit dependencies (npm audit), pin versions, and keep the supply chain in mind. ### Stage 10: Observability Knowing what your service is doing in production. #### Structured logging Emit JSON logs with a logger like pino, and include request context. #### Metrics and tracing _(recommended)_ Expose metrics and add distributed tracing with OpenTelemetry for real visibility. ### Stage 11: Configuration and Tooling Making the codebase pleasant and consistent. #### Config and environment Load and validate configuration from the environment (never hardcode secrets), and fail fast on missing values. #### Linting and formatting _(recommended)_ Set up ESLint and Prettier so style is automatic, not argued about. ### Stage 12: Production and Deployment Getting Node running reliably under real load. #### Containerizing Node Write a small, multi-stage Dockerfile, run as a non-root user, and handle signals for graceful shutdown. #### Scaling with clustering _(recommended)_ Use the cluster module or a process manager (PM2) or container orchestrator to use all CPU cores and stay up across restarts. #### Performance profiling _(recommended)_ Profile CPU and memory, find event-loop lag, and fix the real bottleneck rather than guessing. ### Stage 13: Beyond the Basics Where to go once the fundamentals are solid. #### Real-time (WebSockets) _(optional)_ Add real-time features with ws or Socket.IO, and understand the scaling implications. #### Meta-frameworks and monorepos _(optional)_ Explore NestJS for structure, or a monorepo setup for sharing code across services.