JavaScript runtime
Express servers, async patterns, streams, and REST APIs for university JavaScript coursework. The hardest Node.js exam question is the timing difference between process.nextTick, setImmediate, and setTimeout(0), the event-loop phase ordering our tutors annotate inline. Verified CS graduates from Purdue, BITS Pilani, and Georgia Tech, starting at $20 per task, 12-hour average turnaround.
About
Node.js is a JavaScript runtime built on the V8 engine that runs server-side code, command-line tools, and build pipelines. The 22.x LTS line ships with native fetch, native test runner (node --test), the watch mode (node --watch), and ECMAScript Modules as a first-class alternative to CommonJS. Students meet Node.js in web development electives, full-stack capstones, scripting courses, and any class that uses npm to install build tools (webpack, vite, eslint, prettier, jest).
The runtime is single-threaded but uses libuv to multiplex I/O across an event loop with 6 phases: timers (setTimeout, setInterval callbacks), pending callbacks (some system operations), idle and prepare (internal), poll (incoming I/O, blocking until timeout or events), check (setImmediate callbacks), and close callbacks (cleanup for closed handles). Between phases the runtime drains process.nextTick callbacks and microtasks (Promise.then, queueMicrotask), which is why nextTick fires before setImmediate even though setImmediate is scheduled first in source order. CSHH tutors deliver Express servers with proper middleware ordering (helmet, cors, body-parser before routes, error handler last), async/await error handling that wraps awaited promises in try/catch or uses an asyncHandler wrapper, streams for memory-efficient file processing (createReadStream piped through transform streams to createWriteStream), npm package authorship with semantic versioning and TypeScript declaration files, and Jest or Vitest test suites with supertest for HTTP integration tests.
Coursework
Express routes for CRUD operations (GET /users, POST /users, PUT /users/:id, DELETE /users/:id), Mongoose schemas with validators and pre-save hooks for password hashing via bcrypt, jsonwebtoken for stateless auth, express-validator for input validation, and async/await throughout. Tutors include supertest integration tests that hit each endpoint, plus the MongoDB Memory Server for tests that need no external database.
npm package with a bin entry pointing to a #!/usr/bin/env node shebang script, commander for argument parsing (positional, options, sub-commands), chalk for colored output, ora for progress spinners, and inquirer for interactive prompts. Tutors include the package.json files array to control what ships, and test the CLI via execSync from a Jest test.
createReadStream on a large CSV (1GB+), piped through a Transform stream that parses rows with csv-parser, filters them, transforms fields, and writes to a new file via createWriteStream. Memory stays under 50MB regardless of input size because data flows in chunks. Tutors include backpressure handling and error propagation through pipeline() from node:stream/promises.
Type definitions in SDL, resolvers as async functions, DataLoader to batch and cache database lookups (solves N+1 the GraphQL way), context with the authenticated user, directives for permission checks, and subscriptions over WebSocket for real-time updates. Tutors include integration tests with @apollo/server testing helpers.
WebSocket server attached to an HTTP server (express + http.createServer + new WebSocketServer({ server })), broadcast on incoming messages, rooms for grouped clients, heartbeat ping/pong to detect dropped connections, and Redis adapter for scaling across multiple Node processes (socket.io-adapter-redis).
Express endpoint for incoming POST webhooks (Stripe, GitHub, Slack), raw body parsing via express.raw({ type: "application/json" }), HMAC-SHA256 signature verification using the timing-safe crypto.timingSafeEqual (prevents timing attacks), idempotency via Redis SETNX on the event id, and acknowledge-then-process pattern that returns 200 immediately and processes in a worker queue.
node-cron for simple schedules in-process (cron.schedule("0 2 * * *", handler) for 2am daily), or BullMQ for distributed job queues backed by Redis with retries, delayed jobs, repeatable jobs, and a separate worker process. Tutors deliver a runnable docker-compose with Redis when BullMQ is the right fit.
Debugging
app.get("/users/:id", async (req, res) => {
const user = await db.findUser(req.params.id);
// if findUser rejects, unhandled rejection -> process exits in Node 15+
res.json(user);
});const asyncHandler = (fn) => (req, res, next) =>
Promise.resolve(fn(req, res, next)).catch(next);
app.get("/users/:id", asyncHandler(async (req, res) => {
const user = await db.findUser(req.params.id);
res.json(user);
}));// pipe() ignores the writable's drain signal,
// memory grows unbounded on slow consumers
src.pipe(transform).pipe(dest);import { pipeline } from "node:stream/promises";
await pipeline(src, transform, dest);process.nextTick callbacks run between every phase of the event loop (specifically, after the current operation completes and before the loop continues). setImmediate callbacks run in the dedicated check phase, which is after poll. So scheduling both in the same tick: nextTick fires first regardless of source order. Inside an I/O callback (e.g., fs.readFile callback): setImmediate fires before setTimeout(0) because the loop is already past timers and proceeds to check next. Outside I/O (in the main module): the order between setTimeout(0) and setImmediate is non-deterministic because the timers phase may or may not have started.
Calling emitter.on("event", handler) inside a request handler without ever removing the listener leaks memory. The MaxListenersExceededWarning fires at 10 listeners on the same event. Use emitter.once if the listener should fire once, store the handler reference and call emitter.off in a cleanup, or use AbortController.signal with the abortable EventTarget API.
A package with "type": "module" cannot use require() directly. Either use the dynamic import() that returns a promise, switch the package to "type": "commonjs", or use named exports with both: declare an ESM index.mjs and a CommonJS index.cjs with exports in package.json. Symptom: ERR_REQUIRE_ESM or ERR_MODULE_NOT_FOUND on import.
writable.write() returns false when the internal buffer is full, signaling backpressure. Ignoring the return value lets memory grow unbounded on slow consumers. Either listen for the drain event before writing more, or use the pipeline() helper from node:stream/promises which handles backpressure automatically and propagates errors. Always use pipeline over pipe() for new code.
POST endpoint returns SyntaxError: Unexpected token in JSON at position 0. Likely causes: client sent application/x-www-form-urlencoded but server expects JSON (add the matching express.urlencoded middleware), client sent multipart/form-data (add multer middleware), or client sent malformed JSON (wrap the JSON parser with custom error handler that returns 400 instead of crashing).
emitter.on("event", async (data) => { /* throws */ }) does not have anywhere to send the rejection. Handle inside the async function with try/catch, or wrap the emitter to convert errors into an error event the application listens for.
Code Examples
import express from "express";
import helmet from "helmet";
import cors from "cors";
const app = express();
app.use(helmet()); // security headers first
app.use(cors({ origin: process.env.WEB_ORIGIN }));
app.use(express.json({ limit: "1mb" }));
app.get("/health", (_req, res) => res.json({ ok: true }));
app.use("/api/users", usersRouter);
// 404 + error handler must be LAST
app.use((_req, res) => res.status(404).json({ error: "not_found" }));
app.use((err, _req, res, _next) => {
console.error(err);
res.status(500).json({ error: "internal" });
});
app.listen(3000, () => console.log("listening on :3000"));import { pipeline } from "node:stream/promises";
import { createReadStream, createWriteStream } from "node:fs";
import { parse } from "csv-parse";
import { Transform } from "node:stream";
await pipeline(
createReadStream("orders.csv"),
parse({ columns: true }),
new Transform({
objectMode: true,
transform(row, _enc, cb) {
if (row.status === "paid") this.push(JSON.stringify(row) + "\n");
cb();
},
}),
createWriteStream("paid.ndjson")
);Related
FAQ
Submit your Node.js assignment and get a working, commented solution within 12 hours from a verified CS graduate. Plagiarism-free, line-by-line annotated, with a reproducible test suite where the rubric allows it.
Submit Node.js Assignment