The role of JS in the browser: structure, style, and behaviour.

The V8 / SpiderMonkey engine, JIT compilation, and the rendering pipeline.

Inline scripts, external files, defer vs async attributes.

Differences in scope, hoisting, and mutability between the three declaration keywords.

String, Number, BigInt, Boolean, undefined, null, and Symbol.

Runtime type checking and JavaScript's implicit type conversion rules.

+, -, *, /, %, **, and compound assignment (+=, -=, etc.).

== vs === (abstract vs strict equality) and comparison operators.

&&, ||, !, ??, and optional chaining (?.).

if/else if/else, ternary operator, and switch/case statements.

for, while, do-while, for...of, and for...in loops.

Control loop execution flow with break, continue, and labelled statements.

Named functions, anonymous functions, and the difference in hoisting behaviour.

Concise syntax, implicit returns, and how arrow functions handle this.

Set default values, collect extra arguments with rest (...args), and spread arrays.

Functions that accept or return other functions the basis of functional patterns.

Global, function, and block scope how JS resolves variable lookups.

A function bundled with its lexical environment practical uses and common patterns.

How var declarations and function declarations are moved to the top of their scope.

Immediately Invoked Function Expressions for scope isolation.

Create objects, access properties with dot and bracket notation, and shorthand syntax.

Extract values from objects and arrays into variables using destructuring syntax.

Copy and merge objects with the spread operator and Object.assign.

Configurable, enumerable, writable attributes and Object.defineProperty.

Creating arrays, accessing elements, push/pop/shift/unshift, and length.

Transform, select, and accumulate array values with the three core functional methods.

Search, test, and flatten arrays with modern built-in methods.

Sort arrays correctly with custom comparator functions.

slice, split, trim, replace, includes, startsWith, padStart, and template literals.

Multi-line strings, embedded expressions, and tagged templates.

Patterns, flags, test/match/replace with regex, and capture groups.

Catch runtime errors, execute cleanup code, and re-throw selectively.

Built-in error types: TypeError, RangeError, ReferenceError, SyntaxError, and custom errors.

Extend Error to create domain-specific error types with extra context.

How JS looks up properties through proto and Object.prototype.

Creating objects with new and attaching methods to the prototype.

Manipulate the prototype chain directly without classes.

class, constructor, methods, getters/setters, and static members.

Create subclasses and call parent constructors/methods with super.

Encapsulate implementation details with # private class fields.

Call stack, Web APIs, callback queue, and the microtask queue explained visually.

Traditional async pattern and why deeply nested callbacks are problematic.

Creating promises, .then/.catch/.finally chaining, and promise states.

Promise.all, Promise.allSettled, Promise.race, and Promise.any.

Mark functions as async, await promise resolution, and return values.

Wrap await calls in try/catch and handle rejected promises properly.

Use await outside async functions in ES modules.

import, export, named vs default exports, and re-exports.

require() and module.exports the Node.js module format.

import() for code splitting and lazy loading modules at runtime.

querySelector, querySelectorAll, getElementById, and getElementsByClassName.

innerHTML, textContent, createElement, appendChild, insertAdjacentHTML, and remove.

getAttribute/setAttribute, classList (add/remove/toggle), and inline style.

parentElement, children, nextElementSibling, and closest.

Attach and detach handlers, event types, and the event object.

How events propagate up the DOM tree and how to control propagation.

Attach a single listener to a parent to handle dynamic child elements efficiently.

Create and dispatch custom events with CustomEvent and dispatchEvent.

Make HTTP requests, handle JSON responses, and manage headers and methods.

Persist key/value data in the browser across sessions or tabs.

pushState, replaceState, and the URLSearchParams interface.

Efficiently detect element visibility and size changes without scroll events.

input, change, submit events reading values and preventing default.

checkValidity, setCustomValidity, and the ValidityState interface.

Collect and serialize form data for XHR or Fetch submissions.

What triggers layout recalculation and how to batch DOM reads/writes.

Schedule visual updates in sync with the browser's paint cycle.

Limit the rate of expensive event handlers like scroll and resize.

Move heavy computation off the main thread to keep the UI unblocked.

The event loop in Node, libuv, non-blocking I/O, and the global object.

fs, path, os, http, events, stream, and util built-in modules.

process.argv, process.env, process.exit, and stdin/stdout streams.

init, install, uninstall, run scripts, and understanding package.json.

MAJOR.MINOR.PATCH versioning, caret (^), tilde (~), and lock files.

Alternative package managers workspaces, performance, and hoisting differences.

Create, version, and publish a package to the npm registry.

app.get/post/put/delete, route params, query strings, and request/response objects.

Built-in, third-party, and custom middleware the middleware stack execution model.

Organise routes with express.Router and separate business logic into controllers.

Centralise error responses with four-argument error-handling middleware.

Documents, collections, schemas, models, and CRUD with Mongoose ODM.

Relational data modelling, SQL queries, and using Prisma ORM for type-safe access.

Repository pattern, connection pooling, transactions, and migrations.

Sign, verify, and decode JSON Web Tokens for stateless authentication.

Hash passwords securely with bcrypt never store plain text.

Configure CORS policies and set secure HTTP headers with Helmet.js.

Validate request bodies with Zod or Joi; prevent injection attacks.

Primitive types, arrays, tuples, enums, union/intersection types, and any vs unknown.

Model data shapes, extend interfaces, and choose between interface and type.

Write reusable, type-safe functions and data structures with generic parameters.

Configure the TypeScript compiler, strict mode, and integrate with Vite or tsx.

Write and run unit tests, use matchers, and mock dependencies.

Test Express routes end-to-end with Supertest.

Automate browser interactions and assert UI behaviour with Playwright.

Measure and improve code coverage; avoid chasing 100% blindly.

Lightning-fast dev server with ESM, HMR, and optimised production builds.

Entry points, loaders, plugins, code splitting, and tree-shaking with Webpack.

Ultra-fast builds with esbuild; library bundling with Rollup and ES output formats.

Manage .env files, secrets, and environment-specific config across builds.

Configure ESLint rules, shareable configs (Airbnb, Standard), and custom plugins.

Opinionated code formatter integrate with ESLint and your editor.

Run linters on staged files as a pre-commit Git hook.

Observer, Factory, Singleton, Strategy, and Decorator patterns in JS.

Immutability, pure functions, function composition, currying, and monads.

Build decoupled systems with EventEmitter, pub/sub, and message queues.

Manage multiple packages in a single repo with Turborepo or Nx.