Server-side JavaScript depth, where nearly every question eventually reduces to understanding the event loop and the type system.
10 published across 5 topics.
Node.js and TypeScript fundamentals57 short answers on one page, for revising rather than studying.Phases, microtasks versus macrotasks, blocking the loop, and streams and backpressure.
Something synchronous is occupying the single thread that runs your JavaScript, so every pending request waits behind it regardless of what those requests are doing. The signature is that latency rises for everything at once rather than for one endpoint, which is what distinguishes it from a slow dependency.
The loop cycles through timers, pending callbacks, poll, check and close phases; after every callback Node drains nextTick then promise microtasks, so nextTick beats promises and both beat any phase callback. setImmediate precedes the next timers phase only when scheduled inside a loop callback.
CommonJS versus ESM, worker threads, clustering, buffers, and process and memory limits.
ESM resolves asynchronously and exposes live read-only bindings, CommonJS resolves synchronously and returns a mutable object, and interop leaks in both directions. Extra cores come from worker threads for CPU work, cluster or replicas for connections, child processes for other programs.
Streaming keeps memory bounded by the chunk size instead of the file size, so throughput no longer depends on the largest input you might receive. Backpressure is the mechanism that keeps that bound honest - the writer tells the reader to pause, and code that ignores the signal buffers the whole file in memory anyway.
Middleware ordering, error handling, DI in Nest, and structuring a service beyond a single file.
Express recognises an error handler only by its four-parameter signature, and only if it is registered after the routes. Express 4 also ignores rejected promises from async handlers, so you must get those to next() yourself; Express 5 forwards them for you.
Middleware runs in registration order, so ordering is behaviour rather than style: the request id precedes logging, the body parser precedes anything reading the body, authentication precedes authorisation, and the error handler goes last because Express only searches forward from the failure.
Structural typing, generics, narrowing, and modelling domain constraints in the type system.
You shrink the set of values the compiler accepts: discriminated unions instead of optional-field soup, branded types so one id cannot stand in for another, and a never-typed fallback that fails the build when a variant is added. Types vanish at runtime, so input is parsed by a schema the type is inferred from.
TypeScript erases at compile time, so a type annotation on request data is an assertion about the future rather than a check. Anything crossing a boundary the compiler cannot see - a request body, a database row, a JSON file, an API response - has to be validated at run time, with the type derived from the validator.
Jest and Vitest, mocking modules, build and bundling choices, and monorepo workflows.
Drive business logic through injected dependencies rather than module mocks, intercept at the process boundary for outbound HTTP and time, and use a real database in a container for anything where the database is the logic — SQL, constraints, transactions and migrations.
Substitute at the network layer or behind your own client interface, not at the HTTP library's function. Stubbing the library couples the test to how you make the call rather than to what you send, so the test keeps passing through refactors that change the request and breaks on refactors that change nothing.