Learn ES modules, closures, promises, async/await, destructuring, and array methods. Most Node confusion is really async-JavaScript confusion.

Learn enough TypeScript to type functions, objects, and async code. Most serious Node codebases use it.

Understand how Node handles I/O with a single-threaded event loop, the phases, and the difference between the microtask and macrotask queues.

Learn why CPU-heavy work blocks the loop and starves every other request, and what to do about it.

Get comfortable with process.env, argv, exit codes, and the module system (CommonJS vs ESM).

Understand dependencies vs devDependencies, semantic version ranges, and lockfiles for reproducible installs.

Know the difference between require and import, and how the package type field and file extensions affect module resolution.

Learn npm scripts and the basics of publishing a package.

Read and write files (sync vs async vs promises), build cross-platform paths, and query the system.

Create a raw HTTP server and understand the EventEmitter pattern that Node is built on.

Learn routing, middleware, and request/response handling. Fastify adds schema validation and speed; Express is the ubiquitous default.

Design clean resources, status codes, and error responses, and validate input at the boundary.

Implement sessions or JWTs, hash passwords properly (bcrypt/argon2), and protect routes.

Use Prisma, Drizzle, or Knex against PostgreSQL, and understand connection pooling.

Version your schema so changes apply consistently across environments.

Know when a document store (MongoDB) or a cache (Redis) fits, and how to use them from Node.

Read and write large data with streams instead of buffering it all in memory, and understand backpressure.

Handle rejected promises, uncaught exceptions, and graceful shutdown so one error does not crash or hang the process.

Write tests with the built-in node:test runner, Vitest, or Jest, and test your API against a real test database.

Mock external services, and use coverage to find untested paths without chasing 100%.

Guard against injection, validate and sanitize input, set security headers (helmet), and manage secrets outside the code.

Audit dependencies (npm audit), pin versions, and keep the supply chain in mind.

Emit JSON logs with a logger like pino, and include request context.

Expose metrics and add distributed tracing with OpenTelemetry for real visibility.

Load and validate configuration from the environment (never hardcode secrets), and fail fast on missing values.

Set up ESLint and Prettier so style is automatic, not argued about.

Write a small, multi-stage Dockerfile, run as a non-root user, and handle signals for graceful shutdown.

Use the cluster module or a process manager (PM2) or container orchestrator to use all CPU cores and stay up across restarts.

Profile CPU and memory, find event-loop lag, and fix the real bottleneck rather than guessing.

Add real-time features with ws or Socket.IO, and understand the scaling implications.

Explore NestJS for structure, or a monorepo setup for sharing code across services.