Full Stack Web Development Back-End Development with Node.js & Express Syllabus

Back-End Development with Node.js & Express syllabus — full chapter and topic list

Expand any chapter to see its topics and sub-topics. This is the whole examinable outline for Back-End Development with Node.js & Express in Full Stack Web Development, not a summary of it.

1. 1

   Node.js Fundamentals

   4 topics

   • Node Runtime and Architecture
     • V8 engine and event-driven model
     • Non-blocking I/O and the event loop
     • Running scripts with Node
   • Modules and npm
     • CommonJS vs ES modules
     • npm and package.json
     • Semantic versioning and scripts
   • Core Modules
     • fs file system module
     • path and os modules
     • http and events modules
   • Asynchronous Patterns in Node
     • Callbacks and error-first style
     • Promises and async/await
     • Streams and buffers
2. 2

   Building Servers with Express

   4 topics

   • Express Basics
     • Creating an Express app
     • Routing and route parameters
     • Serving static files
   • Middleware
     • Application and router-level middleware
     • Built-in and third-party middleware
     • Error-handling middleware
   • Request and Response Handling
     • Parsing request bodies
     • Query and route parameters
     • Response methods and status codes
   • Templating and File Uploads
     • Template engines (EJS, Handlebars)
     • Handling uploads with Multer
3. 3

   Designing RESTful APIs

   4 topics

   • REST Principles
     • Resources and endpoints
     • Statelessness and HTTP verbs
     • API versioning
   • CRUD Operations
     • Create, read, update, delete routes
     • Status codes and responses
   • Validation and Error Handling
     • Input validation (Joi, express-validator)
     • Centralized error responses
   • API Documentation and Testing
     • Swagger/OpenAPI
     • Testing with Postman
4. 4

   Authentication and Security

   4 topics

   • Authentication Strategies
     • Session-based authentication
     • JWT-based authentication
     • OAuth and social login basics
   • Password and Data Protection
     • Hashing with bcrypt
     • Environment variables and secrets
   • Authorization
     • Role-based access control
     • Protecting routes with middleware
   • Web Security Practices
     • CORS configuration
     • Preventing XSS and SQL injection
     • Helmet and rate limiting

Back-End Development with Node.js & Express flashcards for Full Stack Web Development

21 of 57 cards from the Back-End Development with Node.js & Express deck — real questions with worked answers.

1. What is Node.js and what JavaScript engine does it use?

   Node.js is a server-side, cross-platform JavaScript runtime built on Google's V8 engine, allowing JavaScript to run outside the browser.

2. Why is Node.js described as having a single-threaded, event-driven, non-blocking I/O model?

   A single main thread runs the JavaScript via an event loop; I/O operations are offloaded (to libuv's thread pool/OS) and handled asynchronously via callbacks, so the thread is never blocked waiting on I/O.

3. What is the event loop in Node.js?

   The mechanism that continuously checks the call stack and queues, executing callbacks for completed asynchronous operations in defined phases (timers, pending callbacks, poll, check, close).

4. What library gives Node.js its asynchronous I/O and thread pool?

   libuv — a C library providing the event loop, async I/O, and a worker thread pool (default size 4) for operations like file system and crypto.

5. What does process.nextTick() do compared to setImmediate()?

   process.nextTick() callbacks run immediately after the current operation, before the event loop continues (highest priority microtask-like). setImmediate() runs in the 'check' phase of the next loop iteration.

6. What is the difference between CommonJS and ES Modules in Node.js?

   CommonJS uses require()/module.exports and loads synchronously (default for .cjs/.js); ES Modules use import/export, load asynchronously, and are enabled via .mjs or "type":"module" in package.json.

7. What does the package.json file do in a Node project?

   It is the manifest that lists project metadata, scripts, and dependencies/devDependencies, enabling reproducible installs and project configuration.

8. What is the difference between dependencies and devDependencies?

   dependencies are packages needed at runtime in production; devDependencies are only needed during development/testing (e.g., test runners, linters) and are excluded with npm install --production.

9. What is the purpose of package-lock.json?

   It records the exact resolved version of every installed package (and its dependencies), ensuring deterministic, reproducible installs across machines.

10. In semantic versioning (semver), what do the parts of 2.4.1 represent?

    MAJOR.MINOR.PATCH — MAJOR (breaking changes), MINOR (new backward-compatible features), PATCH (backward-compatible bug fixes).

11. What do the ^ and ~ symbols mean in npm version ranges?

    ^ allows updates that don't change the leftmost non-zero digit (compatible minor+patch, e.g. ^1.2.3 → <2.0.0); ~ allows only patch-level updates (e.g. ~1.2.3 → <1.3.0).

12. What is the difference between npm install and npm ci?

    npm install updates/creates package-lock.json and installs based on package.json; npm ci installs strictly from package-lock.json (deleting node_modules first) for fast, reproducible CI builds.

13. What does the Node 'fs' core module provide?

    File system operations (read, write, append, delete, watch files/directories), available in synchronous, callback, and promise-based (fs.promises) forms.

14. What does the 'path' core module do, and name two common methods?

    It handles and transforms file/directory paths cross-platform; e.g., path.join() (joins segments) and path.resolve() (resolves to an absolute path).

15. What is the 'http' core module used for in Node?

    Creating HTTP servers and clients; http.createServer() handles incoming requests and sends responses without any external framework.

16. What are Node.js streams and what are the four types?

    Streams process data in chunks rather than all at once; the four types are Readable, Writable, Duplex (both), and Transform (Duplex that modifies data).

17. What does the 'events' module's EventEmitter class provide?

    A pattern to emit named events and register listeners; .on() subscribes, .emit() fires an event, .once() listens a single time.

18. What is a callback function in asynchronous Node.js, and what is the error-first convention?

    A function passed to an async operation to run on completion; the error-first (Node-style) convention puts the error as the first argument: callback(err, result).

19. What is 'callback hell' and how is it commonly avoided?

    Deeply nested callbacks that make code hard to read/maintain; avoided using named functions, Promises, or async/await.

20. What are the three states of a JavaScript Promise?

    Pending (initial), Fulfilled (resolved with a value), and Rejected (failed with a reason).

21. How does async/await relate to Promises?

    async/await is syntactic sugar over Promises: an async function returns a Promise, and await pauses execution until a Promise settles, letting async code read like synchronous code.

See more Back-End Development with Node.js & Express flashcards →

Planning Back-End Development with Node.js & Express for Full Stack Web Development

Back-End Development with Node.js & Express (Full Stack Web Development) FAQ