Vikramjit Gill
โ Enrolled๐ Dubai, UAE โข Support Eng โ Node.js, TypeScript & Redis
๐ Weekend SatโSun (3โ5 PM IST โข UAE Afternoon)
Launch full-screen from your iPhone / iPad Home Screen
100% Backend-Focused 6-Month Career Program: Master JavaScript ES6+, TypeScript 5, Node.js (V8/libuv/Streams), Express.js REST APIs, MongoDB + Mongoose, PostgreSQL + Prisma, JWT/OAuth2/RBAC, Redis, BullMQ, RabbitMQ/Kafka, Socket.IO, Jest/Supertest, Docker, Nginx & CI/CD across 24 modules and 6 mandatory projects.
Net: $136 + 18% GST ($24 ) โข ~$1 /Hr
โก 3 ร $53 (0% Installments)
Pay $160 One-Time or in 3 Easy 0% Installments of $53 (All-Inclusive โ 0% Interest, No Salary Cut)
Attend SatโSun (2h/day) live sessions with Working IT Professionals (โฅ85% attendance) and ship 100% original GitHub repositories.
Clear โฅ90% in every Topic Mock Test & Spoken MockAttempt AI Interview with unlimited free re-attempts whenever below 90%.
Get 100+ curated IT openings in 6 months + trainer coaching for employer Online AI Assessments (OA) โ or 100% net tuition refund*.
๐ Transparent Distinction: Unconditional Career Support vs. Conditional 6-Month 100% Net Tuition Refund* ($136 )
1. Placement & Career Support (Every Graduate): All graduates receive ATS resume engineering, GitHub portfolio verification, mock technical/HR interviews, and ongoing access to curated hiring drives. 2. 6-Month 100% Net Tuition Fee Refund* Covenant: Activated when you complete (a) ≥85% live weekend attendance, (b) 100% original GitHub module repos & Live Client Project, (c) ≥90% in all 543 Topic Mocks & 543 Spoken AI Interviews (unlimited free retries included), and (d) apply to ≥95% of our 100+ curated IT openings & attend 100% of scheduled interviews within 180 days of graduation. Read our full Placement Guarantee Policy & Fee Refund Policy.
Every month concludes with measurable coding competency, a portfolio repository deliverable, and continuous DSA progression.
Master modern JavaScript ES6+, asynchronous execution internals (closures, prototypes, event loop, microtasks, Promises, async/await), strict TypeScript 5, Git/GitHub PR workflows, Linux CLI, and HTTP/TCP networking fundamentals.
Outcome: Write clean, strictly typed, asynchronous JavaScript & TypeScript backend code, navigate Linux servers confidently, and inspect raw HTTP wire traffic.
Deliverable: Project 1: TypeScript-Based Command-Line Employee Management System.
DSA Focus: Arrays, Strings, Hash Maps/Sets, Two Pointers & Big-O Complexity in TypeScript (22 Problems).
Deep-dive into V8, libuv, Node.js event-loop phases, core modules (fs, crypto, Buffer, Streams & backpressure, worker_threads, cluster), Express.js middleware/routing, OpenAPI/Swagger, and 3-layer Controller-Service-Repository REST architecture.
Outcome: Architect, validate, document, and log modular Express.js + TypeScript REST APIs handling large streams and graceful shutdowns without blocking the event loop.
Deliverable: Project 2: Production-Style Employee Management REST API (Express, TypeScript, Swagger & Postman).
DSA Focus: Sliding Window, Binary Search, Sorting, Recursion & Async Concurrency Machine-Coding (24 Problems).
Master polyglot persistence across MongoDB + Mongoose ODM (BSON modeling, ESR compound indexes, aggregation pipelines, replica-set sessions) AND PostgreSQL 16 + Complete SQL + Prisma ORM (3NF, joins, window functions, EXPLAIN ANALYZE, ACID interactive transactions, migrations).
Outcome: Design, index, query, migrate, and benchmark both NoSQL document stores and ACID relational databases in TypeScript.
Deliverable: Project 3: Multi-Database Inventory Management Backend (MongoDB + Mongoose & PostgreSQL + Prisma).
DSA Focus: Linked Lists, Monotonic Stacks/Queues & Database/Pagination Machine-Coding (22 Problems).
Implement Argon2/bcrypt, rotated/revocable JWT access & refresh tokens, sessions/cookies, OAuth 2.0/OIDC, RBAC & resource permissions, OWASP API Top 10 defenses, Zod/Joi validation, Multer + S3-compatible MinIO presigned uploads, signed webhooks, cron jobs, and Jest/Vitest + Supertest QA.
Outcome: Ship hardened, OWASP-compliant Node.js services verified by >= 80% automated unit and Supertest integration test suites.
Deliverable: Project 4: Secure Authentication and Authorization Service.
DSA Focus: Trees, Heaps/Priority Queues, REST & Auth/RBAC Machine-Coding (22 Problems).
Scale backend throughput using Redis 7 caching/rate-limiting/locks, BullMQ delayed & repeatable worker queues, RabbitMQ exchanges/DLQs, Apache Kafka partitions/consumer groups, authenticated Socket.IO + Redis adapter real-time servers, and resilient Saga/Circuit-Breaker microservices.
Outcome: Engineer low-latency cached APIs, idempotent background workers, real-time WebSocket hubs, and event-driven multi-service architectures.
Deliverable: Project 5: 7-Service E-Commerce Microservices Backend.
DSA Focus: Graphs (BFS, DFS, Topological Sort, Dijkstra), Caching, Rate-Limiting & Queue Machine-Coding (23 Problems).
Profile V8 CPU/heap snapshots & event-loop lag, containerize multi-service backends with multi-stage Docker & Docker Compose, configure Linux servers, PM2, Nginx SSL reverse proxies, and GitHub Actions CI/CD, master Backend System Design interviews, and deliver the Final Enterprise Capstone.
Outcome: Deploy, monitor, load-test, and defend a complete production-ready Enterprise E-Commerce Backend in technical interviews.
Deliverable: Final Capstone (Project 6): Enterprise E-Commerce and Order Management Backend.
DSA Focus: Dynamic Programming & Backend System Design Machine-Coding (22 Problems โ Completing 135 Total Problems).
Practised continuously from Month 1 to Month 6 (Easy โ Medium โ Selected Hard) with constraints, sample I/O, Big-O analysis, and TypeScript 5 & Node.js reference solutions and test cases inside the Student Coding Lab.
Arrays & Strings
12 Problems โข M1
Hash Maps
10 Problems โข M1
Searching & Sorting
10 Problems โข M1
Two Pointers
10 Problems โข M1
Sliding Window
10 Problems โข M2
Recursion
9 Problems โข M2
Linked Lists
8 Problems โข M3
Stacks & Queues
9 Problems โข M2
Trees
9 Problems โข M4
Graphs
9 Problems โข M4
Dynamic Programming
9 Problems โข M3
Asynchronous JavaScript
5 Problems โข M2
REST API Implementation
5 Problems โข M2
Authentication
5 Problems โข M4
Database Queries
4 Problems โข M3
Caching
4 Problems โข M5
Queue Processing
4 Problems โข M5
Backend System Design
3 Problems โข M6
Published transparently so students compare scope honestly before enrolling:
โ Correct Answer: A
'Introduction to JavaScript and Server-Side Execution Environments' is used in production JavaScript Core specifically for: Running high-concurrency JSON APIs, CLI tools, and background workers directly on Linux servers with Node.js.
Practice L1/L2 engineering questions across all 543 NBCP topics. Our AI Interviewer speaks questions aloud and scores your spoken answer across Technical Depth, Clarity, Edge Cases & Confidence.
Every module and topic lists its exact technical subtopics, hands-on code labs, Mock Tests, MockAttempt AI interviews, and explicit What Topic Is Next โ progression so enrolled students and trainers always stay synchronized from Day 1 to Expert mastery.
Engineered to take a learner from Day-1 scratch to Senior/Production-ready expertise across 600 guided hours (~โน25/hr), 24 real GitHub repositories, โฅ90% Mock + AI Viva gates, and 100+ curated IT job openings in 6 months (or 100% net tuition refund*).
Month 1 โ Month 1: JavaScript, TypeScript and Backend Foundations (Weeks 1โ4 (Modules 1โ4))
Month 2 โ Month 2: Node.js Runtime and Express.js Backend Development (Weeks 5โ8 (Modules 5โ8))
Month 3 โ Month 3: Database Engineering and ORM / ODM (Weeks 9โ12 (Modules 9โ12))
Month 4 โ Month 4: API Security, Validation, Advanced Features and Testing (Weeks 13โ16 (Modules 13โ16))
Month 5 โ Month 5: Redis, Queues, Messaging, WebSockets and Microservices (Weeks 17โ20 (Modules 17โ20))
Month 6 โ Month 6: Performance, Docker, Linux/Nginx CI/CD, System Design & Capstone (Weeks 21โ24 (Modules 21โ24))
Module Learning & Hands-On Objectives
ECMAScript specification vs host environments (Node.js server runtime vs browser), V8 JIT compilation, and running scripts via `node --watch`
Function-scoped hoisted `var` pitfalls vs block-scoped `let` and `const`, the Temporal Dead Zone (`TDZ`), and `const` binding vs object mutability
7 primitives (`string`, `number`, `bigint`, `boolean`, `undefined`, `symbol`, `null`) stored by value vs Heap reference objects (`Object`, `Array`, `Function`, `Map`...
Explicit parsing (`Number()`, `Number.parseInt(s, 10)`, `String()`, `Boolean()`) vs implicit `==` / `+` coercion traps, `Number.isNaN()` vs global `isNaN()`, and tru...
Strict equality (`===`, `!==`), arithmetic/exponentiation (`**`), logical short-circuiting (`&&`, `||`, `!`), nullish assignment (`??=`), and ternary expressions
`if / else if / else`, early-return guard clauses flattening nested arrow-antipatterns, and exhaustive `switch` blocks with block scoping
Indexed `for`, condition-driven `while`/`do-while`, iterable `for...of` (`Array`, `Map`, `Set`, `String`), why `for...in` walks inherited prototype keys, and `break`...
Immutable UTF-16 strings, `slice`, `trim`, `toLowerCase`, `includes`, `startsWith`, `split`/`join`, `replaceAll`, `padStart`, and normalizing user emails/slugs
Mutating (`push`, `pop`, `splice`, `sort`) vs non-mutating ES2023+ (`toSorted`, `map`, `filter`, `reduce`, `find`, `findIndex`, `some`, `every`, `flatMap`), and nume...
Object literals, computed keys `[key]`, dynamic property lookup (`Object.hasOwn(obj, key)`), `Object.keys`, `Object.values`, `Object.entries`, `Object.fromEntries`,...
First-class functions, arity, default parameter expressions (evaluated per call!), rest parameters `(...items)`, pure functions vs side effects, and returning struct...
Hoisted declarations vs `const fn = function() {}` expressions vs concise `=>` arrow functions (lexical `this`, no `arguments`, cannot be `new`-constructed, `() => (...
Global, module, function, and `{}` block scopes, scope-chain resolution, function declaration hoisting vs `let`/`const` Temporal Dead Zone (`ReferenceError`), and ES...
Synchronous exception unwinding, custom `class DomainError extends Error` with `cause` chaining (`new Error("msg", { cause: err })`), `finally` resource cleanup, and...
Structured `console.table`/`console.time`, `node --inspect-brk`, VS Code `launch.json` breakpoints, conditional breakpoints, call-stack inspection, and building the...
Build a zero-dependency Node.js ES6+ command-line utility pack implementing immutable payroll tax slabs, array/object grouping pipelines, string/CSV log normalizers, and structured custom Error classes.
Module Learning & Hands-On Objectives
Global & Function Execution Contexts (Creation Phase vs Execution Phase), Variable Environment, Lexical Environment, LIFO Call Stack frames, and `RangeError: Maximum...
How inner functions retain live references to outer lexical environments even after the outer function returns โ powering factory functions, memoization, rate counte...
4 `this` binding rules in priority order: (1) `new` binding, (2) explicit `call`/`apply`/`bind`, (3) implicit method `obj.fn()`, (4) default (`undefined` in strict m...
Invoking functions immediately with explicit `this` (`fn.call(ctx, a, b)` vs `fn.apply(ctx, argsArray)`) vs creating a permanently bound function (`fn.bind(ctx)`)
`Object.getPrototypeOf()`, `Fn.prototype` vs instance `[[Prototype]]`, property lookup delegation along the prototype chain, `Object.create(null)` dictionary maps, a...
How `new` works in 4 steps (create object -> link `[[Prototype]]` -> bind `this` -> return object) and modern `class` syntax (`constructor`, instance methods, `stati...
Modelling cohesive backend entities, value objects, services, and repositories with clear responsibilities rather than anemic global helper bags
`extends`, `super()`, method overriding, polymorphic dispatch across notification/payment strategies (`EmailNotifier`, `SmsNotifier`, `WebhookNotifier`), and favorin...
True runtime-enforced ECMAScript `#private` fields & `#private` methods (inaccessible even via `Object.keys` or `JSON.stringify`!) and exposing narrow public APIs
Nested destructuring, property aliasing (`{ user_id: userId }`), default values (`= 20` triggered ONLY on `undefined`, NOT `null`!), and function parameter destructu...
Immutable shallow updates (`{ ...user, role: "admin" }`), rest omission (`const { passwordHash, ...safeUser } = dbUser`!), and why spread is SHALLOW vs native `struc...
Multi-line strings, `${expr}` interpolation, and how **Tagged Template Literals** (`sql\`SELECT * FROM users WHERE id = \${id}\``) power SQL-injection-safe parameter...
Safe deep access `req.user?.organization?.plan ?? "free"`, optional method `onComplete?.()`, and optional bracket `items?.[0]`
Synchronous dynamic `require()` (`module.exports`) vs static asynchronous ESM (`import` / `export`), file extensions in Node ESM, and interoperability (`import pkg f...
Legacy Node `(err, result) => {}` convention, Pyramid of Doom / Callback Hell, double-invocation hazards, and wrapping legacy callback APIs cleanly with `node:util`...
Promise states (`pending` -> settled `fulfilled` or `rejected` โ immutable once settled!), `.then()`, `.catch()`, `.finally()`, and returning Promises inside `.then(...
How `async` always wraps return values in a Promise, how `await` suspends ONLY that async function (freeing the Node.js event loop for other requests!), and avoiding...
Exact failure semantics: `Promise.all` (fail-fast on 1st reject), `Promise.allSettled` (waits for all -> `{ status, value | reason }`), `Promise.race` (1st settled w...
How single-threaded JS achieves high I/O concurrency: Call Stack empties -> drain ALL Microtasks -> pick next Macrotask -> drain Microtasks -> repeat
Priority order in Node.js: Synchronous Stack -> `process.nextTick` -> Promise Microtasks (`.then`, `await` continuations, `queueMicrotask`) -> Macrotasks (`setTimeou...
`try / catch` around `await`, why `return fn()` vs `return await fn()` differs inside `try / catch` blocks (`return fn()` skips local `catch`!), and handling `unhand...
V8 Young Generation (`Scavenge` Nursery) vs Old Generation (`Mark-Sweep-Compact`), root reachability, and the 4 classic Node.js memory leaks (unbounded in-memory cac...
Implement a pure JavaScript `pLimit(concurrency)` task pool, exponential-backoff + full-jitter `withRetry(fn)` wrapper, `AbortSignal.timeout()` cancellable HTTP client, and deterministic microtask/macrotask trace suite.
Module Learning & Hands-On Objectives
Static structural type system + full type erasure at runtime, installing `typescript` + `@types/node`, running via `tsx` in dev vs `tsc` -> `node dist/server.js` in...
When TypeScript infers local constants/variables cleanly vs why explicit parameter and public function/method return types prevent accidental contract drift
Why `unknown` is the type-safe top type (forces narrowing before property access!) vs unsafe `any` (disables type checking!), `never` for exhaustive checks, and `voi...
`string[]`, `readonly string[]` (prevents accidental `.push()`/`.sort()` mutation!), fixed-position tuples `[number, string]`, and why `as const` string literal unio...
Function type aliases `(req: AuthReq) => Promise<ResponseDto>`, callback typing, and function overload signatures when return type depends on input mode
`limit?: number` (`number | undefined`) vs `limit = 20` (`number`), ordering required params before optional params, and `PaginationOptions = { page?: number; limit?...
Tagged **Discriminated Unions** (`type Result<T, E = string> = { ok: true; data: T } | { ok: false; error: E }`) where checking `if (!res.ok)` automatically narrows...
Structural compatibility, `interface` `extends` & declaration merging (needed for augmenting `Express.Request.user`!) vs `type` aliases supporting Unions, Tuples, an...
Control-flow narrowing (`typeof`, `instanceof`, `"code" in err`, `Array.isArray`), user-defined type predicates (`function isAppError(e: unknown): e is AppError`), a...
Exact literal types (`HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE"`), template literal types (``EventKey = `${Domain}.${Action}` ``), and `satisfies` ope...
Type parameters `<T>`, `<K, V>`, constraining `<T extends { readonly id: string }>`, and default generic parameters `<T = unknown>`
Designing `interface Repository<T, CreateInput, UpdateInput>` implemented identically by `InMemoryRepo` (unit tests), `PrismaRepo` (PostgreSQL), and `MongooseRepo` (...
Constructor parameter properties (`constructor(private readonly repo: UserRepo) {}`), `public` / `private` / `protected` / `readonly`, and `override` (`noImplicitOve...
`abstract class BaseRepository<T>` sharing common pagination/logging helpers while enforcing `protected abstract mapRow(row: unknown): T` on concrete subclasses
`class RedisCacheService implements CachePort`, programming Services against `CachePort` / `MailPort` interfaces so infrastructure adapters remain pluggable
Deriving `PublicUser = Omit<UserEntity, "passwordHash">`, `UpdateEmployeeDto = Partial<Pick<Employee, "department" | "salary">>`, and `RoleMap = Record<Role, readonl...
Type-safe property selectors `<T, K extends keyof T>(obj: T, key: K): T[K]`, deriving types from runtime constants via `typeof`, and unwrapping Promise/function retu...
`verbatimModuleSyntax` / `import type { User } from "./types.js"`, `.js` specifier resolution in `NodeNext`, and why barrel `index.ts` files cause circular-import `u...
Recommended Node 22 LTS backend `tsconfig.json`: `"target": "ES2022"`, `"module": "NodeNext"`, `"moduleResolution": "NodeNext"`, `"rootDir": "src"`, `"outDir": "dist...
`strict: true` (`strictNullChecks`, `noImplicitAny`, `strictBindCallApply`, `useUnknownInCatchVariables`) PLUS `noUncheckedIndexedAccess: true` (`arr[0]` is `T | und...
Typing Express `Request<Params, ResBody, ReqBody, ReqQuery>`, generic `ApiSuccess<T>` & `ApiErrorResponse` envelopes, and separating DB Models from Wire DTOs
Organizing `src/{config, modules/{employees, departments}, shared/{errors, logger, middleware}, app.ts, server.ts}` + `tests/` for clarity and zero cross-layer coupl...
Create a strict TypeScript 5 (`strict: true`, `noUncheckedIndexedAccess: true`, zero `any`) library providing discriminated `Result<T, E>`, generic `InMemoryRepository<T extends { id: string }>`, custom type predicates, and mapped DTO utility types.
Module Learning & Hands-On Objectives
Distributed VCS snapshots, `git config --global user.name/email`, `init.defaultBranch main`, and `core.autocrlf` cross-OS line-ending hygiene
Working Tree -> Staging Index -> Local Repo lifecycle, `git add -p` hunk staging, `git diff --staged`, `git log --oneline --graph`, and atomic Conventional Commits (...
Short-lived feature branches (`feat/employee-search`), fast-forward vs 3-way merge commits, interactive `git rebase main` linear history, and **NEVER rebasing shared...
`git stash push -u` / `pop`, `git restore`, `git reset --soft/--mixed` (local unpushed commits) vs `git revert <sha>` (safe compensating commit on shared branches!)
Origin remotes, why `git fetch` + inspect is safer than blind `git pull`, `git push -u origin <branch>`, and `--force-with-lease` safety
Structuring PR descriptions (Problem, Solution, Test Proof), line-by-line review comments, branch protection rules, and CI status checks (`tsc` + `jest`)
Reading `<<<<<<< HEAD`, `=======`, `>>>>>>> branch` conflict markers, resolving semantic TypeScript/package-lock conflicts, and verifying tests pass before completin...
Node/TS `.gitignore` (`node_modules/`, `dist/`, `coverage/`, `.env`, `.env.*`, `!.env.example`, `*.log`), Trunk-Based Development vs GitHub Flow
FHS layout (`/etc` config, `/var/log` logs, `/opt` & `/srv` apps, `/tmp`, `/proc`), `pwd`, `ls -lah`, `cd`, relative vs absolute paths
`mkdir -p`, `cp -r`, `mv`, `rm`, `touch`, `ln -s` symlinks, `find`, `tar -czf` / `-xzf`, `du -sh` & `df -h` disk-full diagnostics!
User/Group/Other bits (`r=4, w=2, x=1`), `chmod 600 ~/.ssh/id_ed25519`, `chmod 640 .env`, `chown -R nodeuser:nodegroup /srv/api`, and principle of least privilege (n...
`ps aux`, `htop`/`top`, `ss -tulpn` / `lsof -i :3000` (finding what occupies port `3000`!), `SIGTERM` (`15`, graceful shutdown!) vs `SIGKILL` (`9`, immediate forced...
`export KEY=VAL`, child-process inheritance, `env`/`printenv`, systemd `EnvironmentFile=/etc/api/.env`, and exit-status chaining (`&&`, `set -euo pipefail`)
`ssh-keygen -t ed25519`, `~/.ssh/authorized_keys`, `~/.ssh/config` host aliases, `scp`/`rsync` file transfer, and disabling root password login in `/etc/ssh/sshd_con...
`journalctl -u api -f`, `tail -f`, `grep -E`, `jq` JSON log filtering (`cat app.log | jq "select(.level >= 50)"`), and standard `stdin`/`stdout`/`stderr` (`2>&1`) re...
Stateless HTTP clients (browsers, mobile apps, webhook callers, microservices) -> Reverse Proxy (Nginx) -> Node.js Application -> Data/Cache Stores
Recursive resolver -> Root -> TLD -> Authoritative nameserver, `A`, `AAAA`, `CNAME`, `TXT` (SPF/DKIM) records, TTL caching, and inspecting resolution with `dig` / `n...
IPv4 vs IPv6, `127.0.0.1` (loopback ONLY!) vs `0.0.0.0` (all interfaces โ required inside Docker containers!), ephemeral ports vs server ports (`80`, `443`, `3000`,...
TCP 3-Way Handshake (`SYN -> SYN-ACK -> ACK`), ordered reliable byte streams, flow/congestion control, `Keep-Alive` connection reuse vs connectionless low-overhead U...
Plaintext HTTP vs TLS 1.3 encrypted HTTPS (confidentiality, integrity & X.509 server authentication), HTTP/2 multiplexing, and terminating TLS at Nginx (`443 -> http...
Start-line (`POST /api/v1/users HTTP/1.1`), Headers (`Host`, `Content-Type`, `Accept`, `Authorization`, `Content-Length`), blank CRLF separator, and Body stream
Semantics & idempotency of `GET`, `HEAD`, `OPTIONS`, `POST`, `PUT`, `PATCH`, `DELETE`, caching/auth/security headers, and exact status codes (`200`, `201 Created + L...
`Set-Cookie` attributes (`HttpOnly` blocks JS XSS theft!, `Secure` HTTPS-only, `SameSite=Lax|Strict` CSRF defense, `Path`, `Max-Age`) and Redis-backed server session...
`JSON.stringify` / `JSON.parse` rules (`undefined`/functions/Symbols omitted, `Date` -> ISO-8601 string, `BigInt` throws `TypeError` without custom serializer!, circ...
Statelessness, Uniform Interface, Resource identification via URIs, Manipulation through representations, Cacheability (`ETag` / `Cache-Control`), and Layered System
Browser Same-Origin Policy (`scheme + host + port`), Simple vs Preflight `OPTIONS` requests, `Access-Control-Allow-Origin` (explicit allowlist!), `Access-Control-All...
Before touching web frameworks or external databases, a strong backend engineer must master clean TypeScript domain modeling, OOP encapsulation, immutable data transformations, input validation, and crash-safe file I/O. Build a production-quality **TypeScript-Based Command-Line Employee Management System (`emp-cli`)** capable of managing employees, departments, compensation bands, attendance/leave summaries, multi-criteria search/sorting, and atomic JSON/CSV persistence from a Linux/Windows terminal.
Module Learning & Hands-On Objectives
Why event-driven non-blocking Node.js excels at I/O-intensive REST APIs, API gateways, real-time WebSockets, and streaming services (and when CPU-heavy tasks need `w...
Active LTS releases (Node 22 LTS), `.nvmrc` / `"engines": { "node": ">=22.0.0" }`, semantic versioning (`^` vs `~`), and deterministic `npm ci` using `package-lock.j...
4-layer stack: Your TypeScript/JS App -> Node.js Standard Library (`node:fs`, `node:http`) -> C++ Node Bindings -> `V8` + `libuv` + `llhttp` + `OpenSSL` + `c-ares` +...
Parsing AST -> `Ignition` bytecode interpreter -> profiling hot functions -> `Sparkplug`/`Maglev`/`TurboFan` optimizing JIT machine code + Hidden Classes (Shapes) &...
How `libuv` routes TCP/HTTP sockets directly to non-blocking OS kernel multiplexers (`epoll` on Linux, `kqueue` on macOS, `IOCP` on Windows) while delegating blockin...
Why shared-memory mutex races disappear in single-threaded JS, YET logical async interleaving races (`read balance -> await -> write balance`) AND main-thread RegEx...
Observer pattern across Node servers, sockets, streams, and domain buses (`server.on("request")`, `stream.on("data")`, `process.on("SIGTERM")`)
`fs.readFileSync` / `crypto.pbkdf2Sync` / `execSync` (acceptable ONLY once before `server.listen()` at cold boot, NEVER inside request handlers!) vs non-blocking `fs...
All 6 libuv phases in order: (1) `timers` (`setTimeout`/`setInterval`), (2) `pending callbacks`, (3) `idle, prepare`, (4) `poll` (retrieve new I/O events), (5) `chec...
Between EVERY event-loop phase transition/callback, Node drains `process.nextTick` queue followed by Promise Microtask queue before moving on
`setTimeout`, `setInterval`, `clearInterval`, `timers/promises` (`await setTimeout(100, undefined, { signal })`), and `timer.unref()` so background cache-sweep inter...
`beforeExit` vs `exit` (sync only!), `SIGTERM` / `SIGINT` graceful handlers, `uncaughtException` & `unhandledRejection` (log fatal error, flush telemetry, and exit n...
Node 22 built-in standards: global `fetch`, `Headers`, `Request`, `Response`, `AbortController`, `structuredClone`, `crypto.randomUUID()`, `URL`, `TextEncoder`/`Text...
`process.cwd()`, `process.hrtime.bigint()` nanosecond timers, `process.memoryUsage()`, `Buffer.from(str, "utf8")` / base64url encoding, and never attaching request s...
Node 20.6+/22 native `node --env-file=.env dist/server.js`, why all `process.env.*` values are `string | undefined` (`process.env.DEBUG = "false"` is TRUTHY as a str...
Native `node:util` `parseArgs({ options, allowPositionals })` building zero-dependency typed administrative/migration CLI scripts
`node --inspect`, VS Code Attach/Launch configs, `node --trace-warnings`, and `process.report.writeReport()` diagnostic JSON dumps on fatal crashes
`node:perf_hooks` `monitorEventLoopDelay({ resolution: 20 })` tracking `p50`/`p99` event-loop lag in milliseconds and keeping JSON payloads & sync work bounded
Without Express, build a raw `node:http` JSON API router supporting URL path params, graceful `SIGTERM` connection draining, typed `EventEmitter` audit hooks, and non-blocking `node:crypto` `scrypt`/SHA-256 hashing.
Module Learning & Hands-On Objectives
How Node wraps CJS files `(function(exports, require, module, __filename, __dirname) { ... })`, synchronous load semantics, and `exports` vs `module.exports` reassig...
`"type": "module"` in `package.json`, `.mjs`/`.cjs` explicit extensions, asynchronous 3-phase loading (`Construction -> Instantiation -> Evaluation`), and Top-Level...
Named exports (preferred for refactoring & explicit contracts) vs default exports, and `package.json` `"exports"` encapsulating internal private files
How Node caches evaluated modules by resolved real file path (case-sensitivity trap: `./User.js` vs `./user.js` on macOS/Windows loads TWICE, then crashes on Linux!!...
`readFile`, `writeFile`, atomic temp-write + `rename`, `mkdir({ recursive: true })`, `stat`, `opendir` async directory streaming, and `FileHandle` cleanup
`path.join`, `path.resolve`, `path.basename`, `path.extname`, `path.sep` (`\` vs `/`), and verifying `resolved.startsWith(allowedRoot + path.sep)`!
`os.availableParallelism()` (cgroup/container-aware CPU count in Node 19.4+ โ better than `os.cpus().length` inside Docker!), `os.freemem()`, `os.totalmem()`, `os.lo...
Building a framework-free `http.createServer((req, res) => ...)` understanding `IncomingMessage` (Readable stream!) and `ServerResponse` (Writable stream!) + `header...
`on`, `once`, `off`, `emit` (synchronous listener invocation!), special `"error"` event (crashes process if unhandled!), and `events.once(emitter, "ready")` Promise...
`randomBytes`, `randomUUID`, `createHash("sha256")`, `createHmac("sha256", secret)`, `scrypt` password KDF, AES-256-GCM authenticated encryption, and **`timingSafeEq...
`new URL(input, base)`, safe hostname/protocol validation (`url.protocol === "https:"`), automatic encoding, and avoiding legacy deprecated `url.parse()`
Building and parsing query parameters via standard `URLSearchParams` (`append` repeated keys, `getAll`, automatic UTF-8 percent-encoding)
Fixed-size raw byte allocations outside V8 JS string heap (`Uint8Array` subclass), `Buffer.from`, `Buffer.alloc` (zero-filled safe!) vs `Buffer.allocUnsafe` (uniniti...
Processing unbounded data chunk-by-chunk (`default highWaterMark = 64 KB` for `fs` streams, `16 KB` general; `16` objects in `objectMode`) instead of buffering entir...
Flowing vs Paused modes, `Readable.from(asyncGenerator)`, and modern `for await (const chunk of readable)` clean async iteration
`writable.write(chunk)` boolean return (`false` means internal buffer reached `highWaterMark` โ wait for `"drain"`!), `writable.end()`, and `"finish"` vs `"close"`
`Duplex` (independent read/write sides, e.g. TCP `net.Socket`) vs `Transform` (output computed from input, e.g. `zlib.createGzip()`, `crypto.createCipheriv`, custom...
Why legacy `a.pipe(b).pipe(c)` LEAKS file descriptors when `b` or `c` errors/disconnects vs **`await pipeline(a, b, c)`** (`node:stream/promises`) which destroys ALL...
How `pipeline()` automatically pauses a fast `500 MB/s` disk/DB `Readable` whenever a slow `2 MB/s` mobile 4G HTTP `Writable` fills its `highWaterMark`, resuming on...
Combining `createReadStream`, `readline.createInterface({ crlfDelay: Infinity })`, streaming SHA-256 checksums, and `createGzip` for large CSV/log ingestion
`execFile` (no shell spawned โ immune to `; rm -rf` shell metacharacter injection!) & streaming `spawn` vs why `exec(cmdString)` with user input is a critical RCE vu...
Isolated V8 isolates sharing one OS process (`Worker`, `parentPort`, `workerData`, transferable `ArrayBuffer`s), bounded worker pools (`piscina`), keeping main HTTP...
Primary process forking `os.availableParallelism()` worker processes sharing port `:3000` via OS round-robin accept, auto-respawning crashed workers with backoff, vs...
Tuning `UV_THREADPOOL_SIZE` (default `4`, max `1024`, MUST be set in env BEFORE first threadpool call!) when heavy `crypto.scrypt` / `bcrypt` / `zlib` / `fs` workloa...
Complete zero-downtime shutdown sequence on `SIGTERM`: (1) Flip `/readyz` to `503` -> (2) `server.close()` (stop new connections, finish in-flight HTTP requests) ->...
Build a constant-RAM (`< 60 MB` RSS) `stream.pipeline()` processor transforming multi-hundred-MB CSV files into validated gzip-compressed `.ndjson.gz` shards with dead-letter row quarantine and `AsyncLocalStorage` request correlation IDs.
Module Learning & Hands-On Objectives
How Express wraps `node:http` with routing tables, `req`/`res` prototype helpers, and a linear middleware stack
Installing `express` + `@types/express`, strict `tsconfig.json`, and how Express 5 automatically forwards rejected `async` route Promises to error middleware (vs `as...
Wiring `const server = http.createServer(app)` with explicit `keepAliveTimeout` (`65s` > Nginx/ALB `60s` idle timeout to prevent `502` race conditions!) and `headers...
Feature-first modular layout: `src/modules/employees/{employee.routes.ts, employee.controller.ts, employee.service.ts, employee.repository.ts, employee.schema.ts}`
Route methods (`get`, `post`, `put`, `patch`, `delete`), `:id` parameters, route registration order (specific `/employees/stats` MUST come BEFORE `/employees/:id`!),...
Why every `req.query.*` arrives as `string | string[] | ParsedQs | undefined` (`?role=a&role=b` becomes an ARRAY `["a", "b"]` โ HTTP Parameter Pollution `HPP`!)
`req.headers`, `req.get("Idempotency-Key")`, `req.ip`, `res.status(201).location(...).json(...)`, `res.set()`, `res.sendStatus(204)`, and `res.headersSent` guard
`express.json({ limit: "100kb", strict: true })`, `express.urlencoded({ extended: false, limit: "100kb" })`, and handling malformed JSON `SyntaxError` (`400 Bad Requ...
Exact production middleware order: (1) `requestId` + `pino-http` logger -> (2) `helmet` + `cors` -> (3) Rate limiter -> (4) Body parsers -> (5) `/api/v1` Routers ->...
Cross-cutting concerns (`X-Request-Id` correlation header propagation/generation, response-time header, maintenance gate)
Modular sub-routers, `Router({ mergeParams: true })` for nested `/departments/:deptId/employees`, and scoping `authenticate` + `authorize("ADMIN")` to protected rout...
`express.json()`, `express.urlencoded()`, `express.raw({ type: "application/json" })` (essential for Stripe/Razorpay webhook HMAC verification!), and why pure backen...
`helmet` (security headers), `cors` (explicit allowlist), `compression` (gzip/brotli above threshold), `express-rate-limit`, `cookie-parser`, and `pino-http`
Parameterized middleware factories (`validateBody(schema)`, `requirePermission("employees:write")`, `cacheResponse(ttlSeconds)`)
What belongs in an Express handler (parse/extract HTTP -> call Service -> map HTTP status & DTO) vs what NEVER belongs in a handler (SQL/Prisma queries, password has...
Class controllers vs factory object controllers (`createEmployeeController(service)`) avoiding `this` binding pitfalls completely!
Why Express identifies error middleware STRICTLY by `fn.length === 4` (`(err, req, res, next)` โ removing unused `_next` parameter turns it into a normal 3-arg middl...
`AppError(message, statusCode, errorCode, isOperational, details)` distinguishing expected client errors (`400`, `401`, `403`, `404`, `409`, `422`) from unexpected p...
Ensuring every async middleware, route handler, event callback, and stream pipeline forwards errors to `next(err)` without hanging sockets or crashing the worker
Consistent mapping: `POST` create -> `201`, `GET`/`PATCH` -> `200`, `DELETE` -> `204`, async job accepted -> `202`, validation -> `422`/`400`, duplicate unique key -...
Consistent `{ success: true, data, meta? }` and RFC 9457 Problem Details `{ type, title, status, detail, instance, requestId, errors? }` across every service
Validating `params`, `query`, and `body` BEFORE controllers run, stripping unknown fields (preventing mass assignment!), and returning field-level `errors: [{ field,...
Mounting `app.use("/api/v1", v1Router)` vs `Accept-Version` header routing, maintaining `v1` response adapters while introducing breaking schema changes in `/api/v2`
Implementing bounded `?page=1&limit=20` (`maxLimit = 100`) returning `{ items, page, limit, total, totalPages, hasNextPage }` AND cursor `?cursor=...&limit=20`
Whitelisting allowed filter fields (`department`, `status`, `minSalary`, `maxSalary`), whitelisting `sortBy` columns (`createdAt`, `salary`, `name`) + `sortOrder` (`...
Authoring OpenAPI 3.1 specs (`paths`, `components.schemas`, `securitySchemes: bearerAuth`), serving interactive `/api/docs` via `swagger-ui-express`, and keeping doc...
Build a `Controller -> Service -> Repository` Express.js + TypeScript REST API featuring `Zod` `body`/`query`/`params` validation middleware, centralized RFC 9457 Problem Details error handling, cursor pagination, and `/api/v1` versioning.
Module Learning & Hands-On Objectives
Turning imperative business actions (`"promote employee"`, `"deactivate account"`, `"issue refund"`) into clean noun sub-resources (`POST /employees/{id}/promotions`...
When public/partner/CRUD HTTP resource APIs favor REST + OpenAPI vs when ultra-low-latency internal service-to-service binary calls favor `gRPC` + Protobuf
Lowercase kebab-case plural nouns (`/api/v1/purchase-orders`, never `/getPurchaseOrders` or `/Purchase_Order`), consistent `:id` path variables, and query params for...
Natural idempotency of `GET`, `PUT`, `DELETE` vs non-idempotent `POST` โ and making `POST /orders` or `POST /payments` retry-safe via `Idempotency-Key` header + payl...
Machine-parsable `error.code` (`EMAIL_ALREADY_EXISTS`, `DEPARTMENT_HAS_ACTIVE_EMPLOYEES`), human `message`, `requestId`, and field-level `details`
Strict separation between `EmployeeCreateRequest`, `EmployeeDbRecord`, and `EmployeeResponse` (never exposing internal auto-increment PKs, soft-delete flags, or audi...
URI prefix (`/api/v1`) vs Header (`Api-Version: 2026-01-01`), shared domain services serving both `v1Controller` and `v2Controller` via thin DTO transformers
Why `OFFSET 100000 LIMIT 20` scans & discards `100,000` rows (`O(offset)` latency + skipped/duplicate rows on concurrent inserts!) vs **Keyset Cursor Pagination** (`...
Consistent filter query grammar (`status=ACTIVE`, `minSalary=50000`, `joinedAfter=2025-01-01`) and multi-column sort (`sort=-createdAt,lastName`) backed strictly by...
Prefix/trigram/full-text search vs exact ID/email lookup, minimum query length (`>= 2` chars), highlighting/ranking, and debounced rate limits
Keep nesting `<= 2` levels: `POST /departments/:deptId/employees` & `GET /departments/:deptId/employees` are clear, whereas individual lookups use flat `GET /employe...
Bounded batch sizes (`max 100 items` per call!), all-or-nothing transactional batch (`POST /employees/bulk`) vs partial-success `{ succeeded: [...], failed: [{ index...
Fixed Window vs Sliding Window vs Token Bucket, keying by `userId` (authenticated) vs `req.ip` (public/login), and returning `429 Too Many Requests` + `Retry-After`
Documenting authentication schemes, pagination parameters, realistic request/response examples, idempotency headers, and every possible `4xx`/`5xx` error code in Ope...
Exporting version-controlled `postman/collection.json` + `local.environment.json`, chaining `pm.environment.set("employeeId", res.json().data.id)`, and writing `pm.t...
`Controller` (HTTP status, headers, DTO mapping) -> `Service` (use-case orchestration, domain rules, transactions) -> `Repository` (data queries & persistence mappin...
Isolating pure domain calculations, external infrastructure adapters (Mail, Storage, Cache), and HTTP transport concerns
Structuring medium-to-large backends as **Modular Monoliths** first: independent domain modules (`employees`, `departments`, `auth`) communicating through public ser...
Explicit **Composition Root** (`src/container.ts`) wiring `const repo = new ...; const svc = new EmployeeService(repo, deptSvc, logger); const ctrl = makeController(...
Validating ALL environment variables at process boot into one frozen `AppConfig` object โ crashing immediately in `< 10ms` with clear field errors if `PORT`, `DATABA...
Clean behavior differences across `development` (pretty logs, Swagger UI enabled), `test` (ephemeral DB, silent/error logs, mocked mail), and `production` (JSON Pino...
Why `console.log` blocks stdout synchronously on large payloads vs ultra-fast asynchronous **`pino`** JSON logging + `AsyncLocalStorage` injecting `requestId` & `use...
12-point API review rubric: Naming, Idempotency, Pagination bounds, Whitelisted sort/filter, AuthN/AuthZ, Rate limits, Validation, Error envelope, OpenAPI, Logs, Tim...
Transform Month 1โs domain into a full-fledged, production-structured HTTP service! Build a **Production-Style Employee Management REST API** using **Node.js 22, Express.js, and TypeScript 5** following strict `Controller -> Service -> Repository` layered architecture with Employee CRUD, Department & Designation management, multi-field search/filtering/pagination, `Zod` request validation, centralized RFC 9457 error handling, `/api/v1` versioning, OpenAPI 3.1 / Swagger UI documentation, Postman collection, and `Pino` correlation-ID structured logging.
Module Learning & Hands-On Objectives
OLTP vs OLAP, write-ahead journaling, read/write amplification, working-set RAM sizing, and access-pattern analysis
Relational ACID tables (schema-on-write, arbitrary ad-hoc joins, foreign keys) vs Document/Key-Value/Wide-Column stores (schema flexibility, single-document locality...
WiredTiger cache (~50% of available RAM), document-level concurrency control, snappy/zstd block compression, `oplog` replication, and journaling
Dynamic vs JSON-Schema validated collections (`validator: { $jsonSchema: ... }`), `_id` immutability, and the hard `16 MB` BSON document ceiling
12-byte `ObjectId` (`4B timestamp + 5B random + 3B counter` โ naturally roughly time-ordered!), `Int32`/`Int64`, `Decimal128` (exact decimal math!), `ISODate` (`new...
Running `mongo:7` in Docker with a single-node replica set (`--replSet rs0`, required locally to test multi-document transactions & Change Streams!) and `mongosh`
Replica-set `M0/M10+` clusters, `mongodb+srv://` DNS seedlist connection strings, SCRAM auth, IP/VPC peering allowlists, and automated snapshots
Inspecting document schema distributions, index usage hit counts, and visual Explain Plans (`Keys Examined` vs `Docs Examined` ratio!)
`insertOne`, `insertMany({ ordered: false })`, `find`, `updateOne` (`$set`, `$unset`, `$inc`, `$push`, `$addToSet`, `$pull`), `findOneAndUpdate(..., { returnDocument...
Comparison (`$eq`, `$ne`, `$gt`, `$gte`, `$lt`, `$lte`, `$in`), logical (`$and`, `$or`), and why array-of-objects queries MUST use **`$elemMatch`** so conditions mat...
Inclusion `{ title: 1, pricePaise: 1 }` vs exclusion `{ internalCost: 0 }`, **Covered Queries** (`totalDocsExamined === 0` when all projected fields live in the inde...
Why `.skip(50000).limit(20)` walks 50,020 index entries vs keyset `{ _id: { $lt: lastObjectId } }` or compound `{ $or: [{ createdAt: { $lt: ts } }, { createdAt: ts,...
Embedding tightly owned, bounded `1:1` and `1:Few` data (`order.shippingAddress`, `product.dimensions`, `product.variants` `<= 50`) read & updated together atomicall...
Referencing `categoryId` / `brandId` when cardinality is unbounded (`1:Many` / `1:Squillions`, e.g., `reviews` referencing `productId`!) + caching `{ id, name, slug...
Choosing `1:1` embedded (`user.preferences`) vs split collection (large rarely-read `product_raw_audit`), and `1:Few` vs `1:Many` vs `1:Millions`
Bounded two-way array of IDs (`product.tagIds[]` `<= 20`) with multikey index vs dedicated association collection (`warehouse_stock` with metadata `aisle`, `bin`, `u...
6 core MongoDB patterns: Embedded, Extended Reference, Subset (keep latest 5 reviews inline + rest in `reviews`!), Computed (`ratingAvg`), Bucket (IoT/metrics), and...
B-Tree indexes in MongoDB and the golden **ESR Rule** for compound index field order: **1. Equality** (`status: "ACTIVE", categoryId: X`) -> **2. Sort** (`pricePaise...
`{ unique: true }` (`E11000` duplicate guard), `{ partialFilterExpression: { deletedAt: null } }` (unique active email even with soft deletes!), `{ expireAfterSecond...
Streaming stage-by-stage transformation pipeline, pushing `$match` & `$sort` to Stage 1 so B-Tree indexes execute BEFORE heavy `$group`/`$lookup` stages, and `allowD...
Filtering (`$match`), grouping accumulators (`$sum`, `$avg`, `$min`, `$max`, `$count`, `$push`), reshaping/computed fields (`$project` / `$addFields`), and top-N `$s...
Correlated/sub-pipeline `$lookup` (always ensure the foreign field is indexed!), `$unwind` (`preserveNullAndEmptyArrays: true`), and `$facet` returning `{ items, tot...
Multi-document ACID sessions (`session.withTransaction` with automatic transient-transaction retry, `< 60s` max duration), SCRAM least-privilege DB users, TLS, and `...
Design a MongoDB 7 + Mongoose 8 product & review backend featuring embedded vs referenced modeling, multi-stage `$match -> $group -> $facet` analytics pipelines, `.lean()` read paths, and `explain("executionStats")` ESR compound index verification.
Module Learning & Hands-On Objectives
What Mongoose adds (schema enforcement, TypeScript inference, middleware hooks, population, query builders) vs raw `mongodb` driver overhead, and when `.lean()` give...
`mongoose.connect(uri, { maxPoolSize: 20, serverSelectionTimeoutMS: 5000, socketTimeoutMS: 45000, autoIndex: !isProd })`, connection events (`connected`, `error`, `d...
`new Schema<IProduct>({ ... }, { strict: "throw", timestamps: true, versionKey: "__v" })` rejecting undeclared fields instead of silently dropping or saving typos
`model<IProduct>("Product", ProductSchema)`, model collection pluralization (`collection: "products"` explicit!), `.isModified()`, `.toObject()`, and `toJSON` transf...
`String` (`trim`, `lowercase`, `minLength`, `maxLength`, `enum`, `match`), `Number` (`min`, `max`), `Boolean`, `Date`, `Schema.Types.ObjectId`, `Schema.Types.Decimal...
Custom `validate: { validator: (v) => ..., message: ... }` functions, SKU format checks, and why uniqueness (`unique: true`) is a MongoDB **INDEX**, NOT a Mongoose v...
Function defaults (`default: () => randomUUID()` vs static value trap!), `immutable: true` (`tenantId`, `createdBy`, `sku`), and `timestamps: { createdAt: true, upda...
Adding domain methods on `schema.methods` (`function` keyword โ NEVER arrow `() =>` which loses `this`!), `schema.statics`, and chainable `schema.query.active()`
4 distinct middleware types: **Document** (`validate`, `save`, `deleteOne`), **Query** (`find`, `findOneAndUpdate`, `updateOne`), **Aggregate**, and **Model** (`inse...
Why `Model.findOneAndUpdate()` and `Model.updateOne()` trigger **Query** middleware (where `this` is the `Query`, NOT the document!) and NEVER run `pre("save")` docu...
`Model.create`, `findById`, `find`, `findOneAndUpdate(filter, update, { new: true, runValidators: true })`, `deleteOne`, and `mongoose.set("runValidators", true)` gl...
Enabling `mongoose.set("sanitizeFilter", true)` + validating inputs as primitive `string`s in Zod so `{ "email": { "$gt": "" } }` attacker JSON cannot bypass login f...
`.populate({ path: "categoryId", select: "name slug" })` (executes 1 batched `$in` query across the page, NOT N queries โ UNLESS you call `await doc.populate()` insi...
Computed non-persisted properties (`priceInRupees`), virtual populate, and why `.lean()` omits virtuals by default (compute DTO fields in your clean TypeScript DTO m...
`ProductModel.aggregate<CategoryStat>([...])` noting Mongoose does NOT auto-cast string `"65f..."` to `Types.ObjectId` inside `.aggregate({ $match })` (cast `new Typ...
`const session = await mongoose.startSession(); try { await session.withTransaction(async () => { ... }); } finally { await session.endSession(); }`
Declaring compound/unique/TTL indexes on schemas, setting `autoIndex: false` in `NODE_ENV=production` (prevents startup index builds locking/slowing boot!), and sync...
Combining `.find(filter).select("sku title pricePaise").sort(...).limit(20).lean()` + `.cursor()` async iteration for batch jobs + `.explain("executionStats")` asser...
Sizing `maxPoolSize` (`10โ25` per Node process: `totalConnections = replicas * maxPoolSize < Atlas/Mongo limit!`), `minPoolSize`, and monitoring pool checkout wait t...
Mapping `MongoServerError` (`code === 11000` -> `409 Conflict` extracting duplicate key name!), `Error.CastError` (invalid `24-hex` ObjectId -> `400 Bad Request`), `...
Implementing `class MongooseProductRepository implements ProductRepository` returning clean domain POJOs (`ProductEntity`) so `ProductService` has zero `import mongo...
Explicit `interface ProductDoc` + `Schema<ProductDoc>` + `HydratedDocument<ProductDoc>`, `InferSchemaType<typeof ProductSchema>`, and strict `Types.ObjectId` vs `str...
Author a 3NF PostgreSQL 16 schema (`accounts`, `journal_entries`, `ledger_postings`) using `NUMERIC(14,2)`, `CHECK` constraints, `NOT EXISTS` anti-joins, recursive CTE category trees, `DENSE_RANK()`/`LAG()` window queries, and `EXPLAIN (ANALYZE, BUFFERS)` tuning.
Module Learning & Hands-On Objectives
Relations (tables), tuples (rows), attributes (columns), domains, set-based declarative SQL vs imperative loops, and Coddโs relational integrity principles
Client backend processes, `shared_buffers` page cache, Multi-Version Concurrency Control (**MVCC**: readers never block writers, writers never block readers!), `VACU...
`CREATE SCHEMA`, `CREATE TABLE`, `GENERATED ALWAYS AS IDENTITY` (modern SQL standard over legacy `SERIAL`!), snake_case identifiers, and idempotent migrations
`BIGINT` / `UUID` (`gen_random_uuid()`), `NUMERIC(14, 2)` (exact decimal currency โ NEVER `REAL`/`DOUBLE PRECISION`!), `TEXT` vs `VARCHAR(n)`, `BOOLEAN`, **`TIMESTAM...
Surrogate keys (`BIGINT` / `UUIDv7`/`v4`) vs natural keys, composite primary keys, `REFERENCES ... ON DELETE RESTRICT | CASCADE | SET NULL`, and **ALWAYS indexing Fo...
Enforcing domain invariants inside the database engine (`CHECK (qty_on_hand >= 0)`, `CHECK (reserved_qty <= qty_on_hand)`, `UNIQUE (warehouse_id, product_sku)`) so e...
Multi-row `INSERT ... VALUES ... RETURNING *`, atomic upsert `INSERT ... ON CONFLICT (warehouse_id, sku) DO UPDATE SET qty_on_hand = inventory_stock.qty_on_hand + EX...
Sargable predicates (`created_at >= $1 AND created_at < $2` uses index vs `EXTRACT(YEAR FROM created_at) = 2026` breaks index!), `IS NULL` / `IS NOT NULL` (never `=...
`COUNT(*)`, `COUNT(DISTINCT user_id)`, `COALESCE(SUM(amount), 0)`, `AVG`, `MIN`, `MAX`, `WHERE` (filters rows before grouping) vs `HAVING` (filters aggregated groups...
Hash Join vs Nested Loop vs Merge Join, `INNER JOIN` vs `LEFT JOIN` (preserving zero-order customers!), and why putting a right-table filter in `WHERE` instead of `O...
Joining a table onto itself with mandatory table aliases (`e.manager_id = m.id` employee-manager org trees, finding duplicate/overlapping shifts)
Scalar subqueries, derived tables, `EXISTS` (short-circuits on 1st match!), and the **deadly `NOT IN` NULL trap** (`WHERE id NOT IN (SELECT parent_id FROM t)` return...
Readable multi-step `WITH` CTE pipelines, data-modifying CTEs (`WITH moved AS (DELETE ... RETURNING *) INSERT INTO archive ...`), and `WITH RECURSIVE` arbitrary-dept...
Ranking (`ROW_NUMBER`, `RANK`, `DENSE_RANK` for Top-N per category!), offset (`LAG`, `LEAD` for MoM growth), and framing (`SUM(amount) OVER (PARTITION BY account_id...
Virtual `CREATE VIEW` (query simplification / column security) vs persisted `CREATE MATERIALIZED VIEW` + unique index enabling zero-lock `REFRESH MATERIALIZED VIEW C...
B-Tree leftmost-prefix rule (`(tenant_id, status, created_at DESC)` serves `(tenant_id)` and `(tenant_id, status)`, NOT `(status)` alone!), Partial indexes (`WHERE s...
**Atomicity** (all or nothing), **Consistency** (constraints satisfied), **Isolation** (concurrent tx safety), **Durability** (committed WAL survives power loss), `B...
Read phenomena (Dirty Read, Non-Repeatable Read, Phantom Read, Serialization Anomaly) and PostgreSQLโs `READ COMMITTED` (default!), `REPEATABLE READ` (snapshot isola...
Pessimistic row locking `SELECT ... FOR UPDATE`, job-claiming `FOR UPDATE SKIP LOCKED`, and preventing **Deadlocks (`40P01`)** by ALWAYS locking multiple rows in det...
Eliminating repeating comma-separated columns (`1NF`), partial key dependencies (`2NF`), and transitive non-key dependencies (`3NF`), plus when controlled snapshot d...
Drawing Crowโs Foot Entity-Relationship Diagrams (`1:1`, `1:N`, `M:N` associative join tables with composite PK/unique + extra attributes), optionality (`0..1` vs `1...
Reading execution trees bottom-up (`Actual Time`, `Rows Removed by Filter`, `Buffers: shared hit` RAM vs `read` disk, `Seq Scan` vs `Index Scan` vs `Index Only Scan`...
Logical backups with custom compressed format `pg_dump -Fc -d app_db -f backup.dump`, `pg_restore --clean --if-exists`, WAL archiving concepts, and regular restore v...
Implement a deadlock-free PostgreSQL + Prisma 5 wallet & seat-booking service using sorted `SELECT ... FOR UPDATE` row locking inside `prisma.$transaction`, optimistic `version` compare-and-swap, `P2002`/`P2025` error mapping, and idempotency keys.
Module Learning & Hands-On Objectives
Declarative `schema.prisma` -> `prisma generate` -> 100% compile-time type-safe `PrismaClient` query builder + Prisma Migrate DDL engine
Installing `prisma` (devDependency) + `@prisma/client` (dependency), configuring `DATABASE_URL` via `.env`, and separating direct DB URL vs pooled URL when needed
Idiomatic camelCase TypeScript fields (`qtyOnHand`, `createdAt`) mapped cleanly onto PostgreSQL `snake_case` columns/tables via `@map("qty_on_hand")` and `@@map("inv...
`@id @default(uuid())` vs `@default(autoincrement())`, `@updatedAt`, native Postgres `enum` mapping, optional `?` (`NULL`), and `@@unique([warehouseId, sku])` + `@@i...
`Decimal @db.Decimal(12, 2)` (`Prisma.Decimal` exact decimal math โ never JS `float`!), `@db.Timestamptz(6)`, `@db.Uuid`, `@db.VarChar(64)`, and `Json` (`JSONB`)
Relation fields vs foreign-key scalar fields, explicit `onDelete: Restrict | Cascade | SetNull`, and disambiguating multiple relations between the same two models (`...
`1:1` (`@unique` FK), `1:N`, and why **Explicit Join Models** (`OrderItem` with `qty`, `unitPricePaise`, `createdAt`) beat implicit Prisma M:N tables whenever relati...
Creating ONE shared `PrismaClient` per Node process (caching on `globalThis` during `tsx watch` dev hot-reloads so dev mode doesnโt leak 50 DB pools!) and calling `$...
`create`, `createManyAndReturn`, `findUnique` / `findFirst`, `findMany`, `update`, `updateMany` (conditional atomic guard `where: { id, qtyOnHand: { gte: n } }, data...
Building typed `const where: Prisma.InventoryStockWhereInput = { ... }` dynamically (`contains`, `mode: "insensitive"`, `in`, `gte`/`lte`, `AND`/`OR`) and determinis...
`skip` + `take` vs high-scale `cursor: { id: lastId }, skip: 1, take: limit + 1` keyset pagination in Prisma
Projecting strictly required columns with `select: { id: true, email: true }`, eager-loading relations via `include` (`relationLoadStrategy: "join"`), and Prismaโs a...
`await prisma.$transaction([op1, op2], { isolationLevel: Prisma.TransactionIsolationLevel.RepeatableRead })` when operations donโt depend on intermediate JS branchin...
`await prisma.$transaction(async (tx) => { ... }, { maxWait: 3000, timeout: 5000, isolationLevel: ... })`, ALWAYS calling **`tx.*`** (NEVER outer `prisma.*`!) inside...
Generating reviewable SQL files in `prisma/migrations/` via `npx prisma migrate dev --name ...`, reviewing destructive `DROP` warnings BEFORE committing, and running...
Writing re-runnable `upsert`-based seed scripts (`npx prisma db seed`) populating reference roles, warehouses, and sample SKUs without throwing duplicate errors on s...
Configuring `?connection_limit=10&pool_timeout=10&connect_timeout=5` in `DATABASE_URL`, matching `(num_containers * connection_limit) < postgres max_connections`, an...
Enabling slow-query event logging (`prisma.$on("query", e => { if (e.duration > 100) ... })`), using **`prisma.$queryRaw\`SELECT ... WHERE id = \${id} FOR UPDATE\``*...
Passing optional `tx?: Prisma.TransactionClient` (defaulting to `this.prisma`) into repository methods so Services can compose multiple repositories inside ONE ACID...
Using `Prisma.InventoryStockGetPayload<{ include: { warehouse: true } }>`, `Prisma.PrismaClientKnownRequestError` (`err.code === "P2002"` unique, `"P2025"` not found...
Testing Repositories & APIs against real ephemeral Docker PostgreSQL + MongoDB instances (never mocking SQL queries that pass in mocks and fail on real DB constraint...
When to use **Prisma** (type-safe relational CRUD/migrations), **Direct Parameterized SQL / `$queryRaw`** (complex CTEs, Window Functions, `FOR UPDATE SKIP LOCKED`,...
Real-world commerce and supply-chain backends frequently combine **polyglot persistence**: document databases excel at flexible, deeply varied product specifications (`laptops` have RAM/CPU, `apparel` has fabric/size/color), while relational databases are non-negotiable for warehouse stock counts, purchase orders, and ACID inventory ledger movements. Build a **Multi-Database Inventory Management Backend** integrating **MongoDB 7 + Mongoose 8** (flexible Product Catalog & Variant Specs) with **PostgreSQL 16 + Prisma 5** (Warehouses, Stock Levels, Reservations, Purchase Orders & Immutable ACID Stock Ledger).
Module Learning & Hands-On Objectives
`Authentication (AuthN)` = verifying identity (`"Who are you?"` -> `401 Unauthorized` when missing/invalid) vs `Authorization (AuthZ)` = verifying permissions (`"Wha...
Canonicalizing email (`trim().toLowerCase()`), constant-message `"Invalid email or password"` responses, and performing a dummy hash compare when user is not found t...
Why fast cryptographic hashes (`SHA-256` runs billions/sec on GPUs!) are catastrophic for passwords vs slow, salted, adaptive key-derivation functions (`Argon2id`, `...
OWASP #1 recommended **`argon2` (`argon2id`, `memoryCost: 65536`)** vs `bcrypt` (`cost = 12`), async threadpool execution (NEVER `hashSync`/`compareSync`!), and `bcr...
Generating `32-byte` CSPRNG token (`crypto.randomBytes(32).toString("hex")`), emailing raw token in link, storing ONLY `SHA-256(token)` + `expiresAt` (`15m`) + `used...
Issuing hashed verification tokens on signup, rate-limiting resend requests (`1 / 60s`), marking `emailVerifiedAt = NOW()`, and gating sensitive actions on verified...
Compact URL-safe `base64url(header).base64url(payload).base64url(signature)` tokens โ **SIGNED (tamper-evident), NOT ENCRYPTED** (anyone can base64-decode payload!)
Symmetric `HS256` (`>= 256-bit` high-entropy secret) vs asymmetric `RS256`/`EdDSA` (Auth Service signs with private key; Microservices verify with public key!), and...
Pairing short-lived stateless `Access Token` (`10โ15 min` in `Authorization: Bearer`) with long-lived revocable `Refresh Token` (`7โ30 days` in `HttpOnly` cookie, `S...
On `POST /auth/refresh`: verify presented refresh token -> if already marked `replacedByTokenId != null`, **THEFT DETECTED: revoke ALL tokens in `familyId` immediate...
Combining short `15m` access TTL with a lightweight Redis denylist `SET revoked:jti:<jti> 1 EX <remaining_ttl>` (checked in `< 0.5ms`) for critical immediate logouts...
Opaque CSPRNG `sessionId` cookie mapped to Redis JSON (`sess:<sid>`), sliding TTL renewal, session fixation prevention (**regenerate session ID on login!**), and ins...
Automatic browser `Cookie` attachment vs explicit `Authorization` header, scoping refresh cookies strictly to `Path=/api/v1/auth` so every `/api/v1/products` call do...
`HttpOnly: true`, `Secure: true`, `SameSite: "lax" | "strict"`, and the **`__Host-`** cookie name prefix (`__Host-rt` forces browser enforcement of `Secure`, `Path=/...
Roles (`Resource Owner`, `Client`, `Authorization Server`, `Resource Server`), why Implicit Flow is dead, **Authorization Code + PKCE (`code_verifier` / `code_challe...
Why OAuth 2.0 alone is an *authorization* protocol vs **OIDC** (`openid email profile` scopes) adding standardized identity `id_token` JWTs verified against provider...
Redirecting to Google Auth URL (`state`, `code_challenge`) -> exchanging `code` server-to-server -> verifying `id_token` via `google-auth-library` / `jose` JWKS -> u...
Modelling `CUSTOMER`, `SELLER`, `SUPPORT`, `ADMIN` roles and enforcing role gates on Express routers (`requireRoles("ADMIN", "SUPPORT")`)
Decoupling code from role renames: Roles map to **Permissions** (`orders:read`, `orders:refund`, `products:publish`), and routes check `requirePermissions("orders:re...
**OWASP API1 #1 Vulnerability (`Broken Object Level Authorization`)**: verifying `order.userId === req.user.sub || req.user.role === "ADMIN"` inside the query/policy...
Users holding multiple roles or workspace memberships (`organization_members(orgId, userId, role)`), scoping active `X-Organization-Id` verified against DB/cache mem...
Chaining `authenticate -> requireVerifiedEmail -> requirePermissions("products:write")` cleanly with 100% TypeScript narrowing
Build a standalone Express + TypeScript authentication core implementing `Argon2id` password hashing, `15m` JWT access tokens, `HttpOnly` rotated refresh-token families with SHA-256 DB storage & reuse revocation, and BOLA-proof ownership middleware.
Module Learning & Hands-On Objectives
API1 BOLA, API2 Broken Auth, API3 Broken Object Property Level Auth (Mass Assignment & Excessive Data Exposure!), API4 Unrestricted Resource Consumption, API5 Broken...
Allowlist validation (strict types, lengths, regexes, enums via Zod) OVER blocklist string stripping, plus Unicode normalization and prototype-pollution key blocking...
Why parameterized placeholders (`$1, $2` in `pg`, Prisma ORM methods, and `prisma.$queryRaw\`...\`` tagged templates) separate SQL AST compilation from data values โ...
Blocking JSON operator objects (`{ "$ne": null }`, `{ "$gt": "" }`, `$where` JS execution!) via Zod `z.string()` validation + `mongoose.set("sanitizeFilter", true)`
Enforcing `Content-Type: application/json; charset=utf-8` + `X-Content-Type-Options: nosniff` on APIs, escaping HTML in server-generated emails/PDFs, and `HttpOnly`...
When CSRF applies (cookie-authenticated state-changing endpoints; NOT pure `Authorization: Bearer` header APIs!), defending cookie endpoints via `SameSite=Lax|Strict...
Dynamic `origin(reqOrigin, cb)` checking an explicit `Set<string>` allowlist, `credentials: true`, explicit `methods` & `allowedHeaders`, `maxAge: 86400` caching `OP...
`Strict-Transport-Security` (`HSTS`), `X-Content-Type-Options: nosniff`, `X-Frame-Options: DENY`, `Referrer-Policy: no-referrer`, and `Content-Security-Policy: defau...
Multi-layer rate limits: Nginx edge IP burst limit + Express Redis-backed per-user/per-IP sliding windows (`express-rate-limit` + `rate-limit-redis`)
Dual-key tracking on `/login`: (1) per-IP limit (`30 / 15m` protecting corporate NATs) AND (2) per-`email` failure counter (`5 failed -> 15m cooldown` blocking distr...
NIST SP 800-63B modern rules: length (`>= 8โ12` chars up to `128`), allowing spaces/passphrases, screening common breached passwords (`password123`, `qwerty12345`),...
Hashing refresh tokens, API keys (`sk_live_...`), OTPs, and reset tokens with `SHA-256` BEFORE storing in PostgreSQL/MongoDB โ just like GitHub/Stripe show an API ke...
Supporting **Key Ring Arrays** (`JWT_SECRETS = [currentKey, previousKey]`: sign with `keys[0]`, verify trying `keys[0]` then `keys[1]`) so signing keys rotate with Z...
Enforcing minimum secret entropy (`JWT_SECRET.length >= 32`), forbidding dev defaults (`"changeme"`, `"secret"`) when `NODE_ENV === "production"`, and freezing confi...
Renaming every uploaded file to a random `UUID` (`never` using original `file.originalname` on disk!), storing outside webroot in private buckets, `Content-Dispositi...
Inspecting actual leading binary file signatures (`%PDF-` = `25 50 44 46`, PNG = `89 50 4E 47`, JPEG = `FF D8 FF`) rather than trusting spoofable `Content-Type` mult...
Bounding `express.json({ limit: "100kb" })`, URL query parameter count (`parameterLimit: 50`), Multer `{ limits: { fileSize: 5 * 1024 * 1024, files: 3 } }`, and JSON...
Using UUIDv4/v7 external IDs instead of sequential `/invoices/1, 2, 3`, protecting coupon/checkout business flows (`API6`), and blocking private IP ranges (`127.0.0....
Running `npm audit --omit=dev --audit-level=high` in CI, pinning lockfiles, disabling untrusted install scripts (`--ignore-scripts` consideration), and preferring na...
Configuring Pino `redact: { paths: [...], censor: "[REDACTED]" }` for `authorization`, `cookie`, `set-cookie`, `*.password`, `*.token`, `*.cvv`, and stripping `\r\n`...
Classifying PII (`PAN`, `taxId`, `bankAccountNumber`), encrypting high-sensitivity fields at rest with `node:crypto` `aes-256-gcm` (unique `12-byte` IV + `16-byte` a...
Recording `security_audit_logs` (`actorUserId`, `action`, `targetType`, `targetId`, `ipAddress`, `userAgent`, `metadata`, `createdAt`) on logins, role changes, passw...
Logging full `{ err, stack, sql, requestId }` internally to Pino while returning ONLY `{ code: "INTERNAL_ERROR", message: "Unexpected error", requestId }` to externa...
Running Node as UID `1000` (`node` user, never `root`), connecting the app with a non-superuser PostgreSQL role (`SELECT, INSERT, UPDATE, DELETE` โ no `DROP DATABASE...
Harden an Express API against NoSQL/SQL injection, mass assignment, prototype pollution, ReDoS, and private-IP SSRF while adding `Helmet`, strict origin allowlist `CORS`, and atomic Redis Lua Token-Bucket / Sliding-Window rate limiters.
Module Learning & Hands-On Objectives
`Zod` (`z.object`, `.strict()`/`.strip()`, `.refine()`, `.transform()`, `z.infer<typeof Schema>` zero-duplication TS types!) alongside `Joi` awareness for existing e...
`z.coerce.number().int().min(1).max(100).default(20)` for query strings, `z.string().uuid()` for params, formatting `ZodError.issues` into clean `422` field error ar...
Running `PublicUserDtoSchema.parse(data)` before `res.json()` (or in tests/staging) as a hard data-leakage firewall guaranteeing `passwordHash` or `secret` can NEVER...
Unified error normalizer converting `ZodError` (`422`), `Prisma P2002` (`409`), `Mongoose 11000` (`409`), `MulterError LIMIT_FILE_SIZE` (`413`), and `TokenExpiredErr...
Router-level `/api/v1` vs `/api/v2`, RFC 8594 `Sunset` & `Deprecation: true` headers, and tracking per-version traffic metrics before retiring old versions
Implementing tamper-checked base64url cursors `{ sortValue, id }` supporting forward (`after`) pagination without `OFFSET` degradation on `10M`-row tables
Supporting range operators (`price[gte]=1000&price[lte]=5000`), multi-select (`status=PAID,SHIPPED`), and safe multi-sort (`sort=-createdAt,pricePaise`)
`prisma.product.createMany({ data, skipDuplicates })`, chunking `5,000` rows into batches of `500` so single SQL packets stay fast, and parameterized `UNNEST` bulk u...
Configuring `multer` (`diskStorage` to `/tmp` with `UUID` filename vs `memoryStorage` ONLY for small `< 2 MB` avatars), `fileFilter`, strict `limits`, and cleaning u...
Why stateless Node containers NEVER store permanent uploads on local container disk (wiped on redeploy & invisible to sibling replicas!) -> storing objects in privat...
Client requests `POST /uploads/presign` (Node checks Auth + quota + MIME/size conditions -> signs a `5-minute` `PUT` URL) -> Client uploads `50 MB` directly to Objec...
Designing clean HTML + plain-text fallback email templates (Welcome, Verify Email, Password Reset, Order Receipt) with HTML-escaped variables and `List-Unsubscribe`...
Configuring `nodemailer.createTransport({ pool: true, maxConnections: 5, connectionTimeout: 5000 })`, testing locally against `Mailpit` / `MailHog` SMTP container (z...
Combining rate limit -> hashed token DB write -> queued reset email -> token verification -> Argon2 password update -> session revocation -> confirmation security al...
Use cases: expiring unpaid `15-minute` inventory reservations, nightly ledger reconciliations, purging expired tokens, and refreshing materialized views
Cron 5-field expressions (`*/5 * * * *`), explicit `timezone: "UTC"`, and why `node-cron` inside 4 API containers fires **4 TIMES** unless moved to BullMQ Repeatable...
Returning `202 Accepted` + `{ jobId, statusUrl: "/api/v1/jobs/..." }` for operations taking `> 500ms` (bulk imports, PDF generation, webhook fan-out)
Streaming CSV rows via `csv-parse` / `fast-csv` + `pipeline()` in `O(1)` memory, AND defending against **CSV Formula Injection** (prefixing leading `=`, `+`, `-`, `@...
Using `exceljs` streaming `WorkbookWriter` / `WorkbookReader` instead of loading entire multi-sheet workbooks into DOM memory
Generating lightweight vector GST tax invoices & receipts server-side using streaming `pdfkit` (`doc.pipe(writeStream)`) rather than spawning a `400 MB` headless Chr...
Inbound webhooks (receiving payment events from Razorpay/Stripe) vs Outbound webhooks (notifying merchant URLs of `order.shipped` with `X-Webhook-Id`, `X-Webhook-Tim...
Signing `${timestamp}.${rawBody}` with HMAC-SHA256, verifying `Math.abs(nowSec - timestamp) <= 300` (`5-minute` replay window!), and comparing digests with `crypto.t...
Why payment gateways deliver webhooks **At-Least-Once** (same `payment.captured` event can arrive 3 times!), guaranteeing exactly-once business effect via `UNIQUE (p...
Generating OpenAPI 3.1 JSON directly from `Zod` schemas (`zod-to-openapi`), exporting client SDK types, and running CI diffs catching accidental breaking contract ch...
Build a secure file upload & invoice attachment service verifying magic-byte file signatures (`file-type`) and S3-compatible `MinIO` presigned `PUT`/`GET` URLs โ backed by an `>= 85%` `Vitest`/`Jest` + `Supertest` integration suite.
Module Learning & Hands-On Objectives
Static Type/Lint checks (`tsc` + `ESLint`) -> Fast Pure Unit Tests -> High-Confidence API + Real-DB Integration Tests (`Supertest`) -> Focused Critical-Path E2E Flow...
Arrange-Act-Assert (`AAA`) structure, testing pure pricing/coupon/token calculators and Services injected with lightweight `InMemoryRepository` fakes in `< 5ms` per...
Verifying actual Prisma/PostgreSQL and Mongoose/MongoDB queries, unique/check constraints, cascade rules, and transactions against isolated test databases
Asserting HTTP status code, `Content-Type`, security/rate/location headers, response JSON schema, AND post-request database/audit state!
Multi-step stateful user journeys (`Register -> Capture OTP from FakeMailer -> Verify Email -> Login -> Access Protected Route -> Rotate Refresh Cookie -> Logout ->...
`Red` (write failing test specifying exact behavior) -> `Green` (write minimal clean code to pass) -> `Refactor` (clean up with green safety net)
Configuring `vitest.config.ts` / `jest.config.ts` (`ts-jest` / native ESM), separating fast `test:unit` from DB-backed `test:integration` (`maxWorkers: 1` or per-wor...
Closing Prisma (`$disconnect`), Mongoose (`disconnect`), and Redis (`quit`) in `afterAll`, using `--detectOpenHandles`, and avoiding port collisions (`supertest` bin...
`request(app).post("/api/v1/auth/login").set("Authorization", ...).send(...)` AND `request.agent(app)` for automatic `Set-Cookie` / `Cookie` jar persistence across r...
`toEqual`, `toMatchObject`, `expect.any(String)`, `expect.stringMatching()`, `.rejects.toThrow(ConflictError)`, and asserting absence of sensitive keys (`expect(res....
Connecting DB pools once in `beforeAll`, resetting table rows + `vi.restoreAllMocks()` in `beforeEach`/`afterEach`, and disconnecting pools in `afterAll`
Creating composable `buildUserOverrides({ role = "USER", isVerified = true } = {})` factories generating unique emails/SKUs (`crypto.randomUUID()`) per call
Using `vi.useFakeTimers()` / `jest.useFakeTimers()` + `advanceTimersByTime(16 * 60 * 1000)` to test `15-minute` token expiry and `15-minute` rate-limit resets in `1...
Golden rule: **Mock external third-party network boundaries** (SMTP, OAuth token endpoint, Payment Gateway HTTP); **DO NOT mock your own database, Zod schemas, or Ex...
Querying `pg_tables` (`schemaname = 'public'` excluding `_prisma_migrations`) to execute a single `TRUNCATE TABLE ... RESTART IDENTITY CASCADE` in `< 8ms` between in...
Systematic tests: valid signup/login, duplicate email (`409`), wrong password (`401`), unverified login policy, expired JWT (`401`), wrong-secret JWT (`401`), `alg:...
Matrix testing `(Anonymous, Customer A, Customer B, Support, Admin)` ร `(Read Own, Read Other, Mutate Other, Admin Route)` verifying `401`/`403`/`404` on every unaut...
Firing `await Promise.all(Array.from({ length: 10 }, () => request(app).post("/coupons/redeem")))` on a `maxUses = 1` coupon or `qty = 1` item โ proving **1 succeeds...
Validating every `Supertest` response JSON against your published OpenAPI 3.1 response schema so undocumented status codes or missing required fields fail tests auto...
Measuring Statements, Branches (`if/else`, `??`, `?:`), Functions, and Lines (`coverageThreshold: { global: { branches: 80, lines: 80 } }`) โ focusing on critical au...
ESLint v9 flat config (`eslint.config.mjs`) + `typescript-eslint` type-aware rules: **`@typescript-eslint/no-floating-promises`** (catches forgotten `await`!), `no-m...
`.prettierrc` + `eslint-config-prettier` + `prettier --check .` in CI eliminating bikeshedding formatting debates in Pull Requests
Running `tsc --noEmit` in CI (because fast test runners like `vitest`/`swc`/`esbuild` transpile TS WITHOUT typechecking!)
Reviewing PRs systematically for: BOLA ownership, SQL/NoSQL parameterization, transaction boundaries, N+1 queries, missing timeouts/idempotency, unredacted logs, and...
Automating `lint + typecheck + unit + integration (with Postgres/Redis service containers)` on every push and completing **Project 4: Secure Authentication and Autho...
Broken authentication, token theft, missing BOLA checks, and brute-force credential stuffing account for the majority of severe backend breaches. Build a standalone, reusable **Secure Authentication and Authorization Service** in **Node.js, Express.js, TypeScript 5, PostgreSQL (Prisma), and Redis** implementing registration, email verification, password reset, `Argon2id` hashing, short-lived JWT access tokens + rotated `HttpOnly` refresh-token families with reuse detection, RBAC + granular permissions, OAuth 2.0 (`PKCE` + `state`) login, Redis Lua rate limiting, and immutable security audit logs โ backed by `>= 80%` `Jest`/`Vitest` + `Supertest` coverage.
Module Learning & Hands-On Objectives
Why single-threaded in-memory Redis executes `100,000+ ops/sec` at sub-millisecond latency (zero context-switching/lock overhead + multiplexed `epoll` I/O), `redis:7...
Choosing the right native structure (`String`, `Hash`, `List`, `Set`, `Sorted Set / ZSET`, `Stream`) instead of serializing giant JSON strings for tiny field updates
`SET key val EX 300 NX` (atomic set-if-not-exists + expiry!), `INCR`/`DECR`, `HSET`/`HMGET`, `LPUSH`/`RPOP`, and `SADD`/`SISMEMBER`/`SCARD` unique counters
`ZADD key score member`, `ZINCRBY`, `ZREVRANGE` top-K rankings in `O(log N + K)`, `ZREMRANGEBYSCORE` pruning expired timestamps, and `ZCARD`
`EXPIRE`/`PEXPIRE`, `TTL`/`PTTL`, cursor-based `SCAN 0 MATCH prefix:* COUNT 100`, `UNLINK` (async non-blocking memory free vs blocking `DEL` on huge keys!), and `red...
Colon-delimited hierarchical keys `{service}:{version}:{entity}:{id}` (`catalog:v1:product:SKU-101` โ bump `v1 -> v2` on DTO schema changes to avoid deserialization...
`new Redis(url, { maxRetriesPerRequest: 3, enableReadyCheck: true, lazyConnect: true })`, error event handling, and `redis.eval(luaScript, numKeys, ...keys, ...args)...
Effective latency `L_eff = hit_rate * L_cache + (1 - hit_rate) * L_db` (`95%` hit @ `0.5ms` + `5%` miss @ `40ms` = `2.47ms` avg!), read-heavy high-fanout candidates...
Read path: `1) Check Redis -> Hit? Return parsed -> 2) Miss? Query DB -> 3) Populate Redis w/ TTL -> Return` + caching negative `"__NULL__"` sentinels (`short 30s TT...
Comparing **Cache-Aside** (only requested items cached), **Write-Through** (write updates DB + Cache synchronously), and **Write-Behind** (write hits Redis fast -> a...
Why **deleting (`UNLINK`/`DEL`)** the cache key AFTER the DB transaction commits beats overwriting the cache value (avoids out-of-order concurrent write overwrite ra...
Why warming 10,000 product keys at boot with exact `EX 3600` causes all 10,000 keys to expire at the EXACT same second 1 hour later (`Cache Avalanche`!) -> adding ra...
Hashing normalized query filter objects (`sha256(canonicalJson)`) into versioned cache keys (`catalog:v1:list:ver_${version}:${filterHash}`) bumped atomically via `I...
Storing `sess:${sid}`, user permission sets (`auth:v1:perms:${userId}` `TTL 5m`), OTP counters, and `revoked:jti:${jti}` with automatic sub-millisecond expiry
Caching serialized JSON + `ETag` (`If-None-Match` -> `304 Not Modified` saving bandwidth!) strictly on `GET` public/tenant-scoped endpoints (`NEVER` cache personaliz...
Atomic Lua Sliding-Window Log (`ZREMRANGEBYSCORE` old hits -> `ZCARD` check `< limit` -> `ZADD now reqUuid` -> `PEXPIRE`) preventing the `2x` boundary burst flaw of...
Acquiring `SET lock:${resource} ${ownerUuid} PX ${ttlMs} NX` AND releasing ONLY via atomic Lua `if redis.call("get", KEYS[1]) == ARGV[1] then return redis.call("del"...
Understanding why distributed Cache + DB is eventually consistent unless serialized, handling stale reads safely, and NEVER treating ephemeral cache as the authorita...
When a hot homepage key expires under `5,000 RPS`, `500` requests simultaneously miss Redis and slam PostgreSQL! Defenses: (1) **In-Process Single-Flight Promise Map...
`RDB` point-in-time fork snapshots vs `AOF` (`appendfsync everysec`) durability, and why **Cache Redis** uses `maxmemory-policy allkeys-lru` whereas **BullMQ Queue R...
Running reproducible load benchmarks with `autocannon -c 100 -d 15` measuring `Req/Sec`, `p50`, `p95`, `p99` latency, and PostgreSQL CPU drop
Implement a typed `ioredis` caching layer featuring Cache-Aside with jittered TTLs, in-process `Map<string, Promise<T>>` Single-Flight stampede coalescing, tag/version invalidation, ZSET leaderboards, and Lua compare-and-delete distributed locks.
Module Learning & Hands-On Objectives
Keeping user-facing HTTP critical path minimal (`validate + write order = 25ms`) while pushing non-blocking side effects (invoice PDF, email, analytics, webhook deli...
Producer (API container enqueues compact JSON `{ orderId }` โ NEVER `10 MB` blobs!) -> Durable Broker -> Independent Worker Processes -> Result/Audit Store
Separating fast high-priority queues (`otp-emails` SLA `< 3s`) from slow bulk queues (`monthly-csv-exports`) so 10,000 CSV exports NEVER delay login OTPs (`Head-of-L...
Cron-driven recurring maintenance vs per-entity delayed timers (`check unpaid order #901 in 15m`)
`attempts: 5`, `backoff: { type: "exponential", delay: 2000 }` (`2s -> 4s -> 8s -> 16s -> 32s`) vs failing immediately (`UnrecoverableError`) on permanent `400` inva...
Routing poison-pill messages that exhaust all `attempts` into a retained Dead-Letter Queue (`DLQ`) with error stack, attempt count, and admin replay tooling
Why EVERY queue guarantees **At-Least-Once** delivery (worker crash right after sending email / charging card but right BEFORE `ack` replays the job!) -> enforcing d...
Tracking `waiting`, `active`, `delayed`, `failed` counts, oldest-waiting job age (`queue lag`), and stalled-job recovery rates
Modern TypeScript-native `bullmq` (`Redis Streams` + atomic Lua scripts replacing legacy `bull`), separate `ioredis` connections for `Queue` vs blocking `Worker` (`m...
Typed `new Queue<OrderEmailPayload, EmailResult, "send-receipt">(name, opts)` and `new Worker(name, async (job) => { ... }, { connection, concurrency: 10 })` + `awai...
`queue.add("send-receipt", payload, { jobId: \`receipt-\${orderId}\` })` โ passing a deterministic `jobId` prevents duplicate waiting jobs for the same order automat...
`attempts`, `backoff`, `priority` (`1` = highest!), and **`removeOnComplete: { age: 3600, count: 1000 }` + `removeOnFail: { age: 86400 * 7, count: 5000 }`** (prevent...
`queue.add("expire-unpaid-order", { orderId }, { delay: 15 * 60 * 1000, jobId: \`expire-\${orderId}\` })` promoted automatically from ZSET to waiting stream when due
`queue.upsertJobScheduler("nightly-reconcile", { pattern: "0 2 * * *", tz: "Asia/Kolkata" }, { name: "reconcile" })` running cluster-safely ONCE per cron tick across...
`concurrency: 15` (parallel async I/O jobs per worker) + `limiter: { max: 14, duration: 1000 }` (pacing outbound calls to respect third-party SMTP/SMS `14 emails/sec...
`await job.updateProgress(45)`, worker `.on("completed")` / `.on("failed")` / `.on("error")` (ALWAYS attach `.on("error")` on `Worker` & `Queue`!), and cross-process...
Mounting `@bull-board/express` behind strict `ADMIN` RBAC, inspecting stacktraces (`job.failedReason`, `job.stacktrace`), `job.retry()`, and `UnrecoverableError`
TCP Connection (`1` per process!) -> Multiplexed lightweight `Channel`s -> `Exchange` (receives from Producer) -> `Bindings` -> `Queue` (buffers messages) -> `Consum...
Why Producers NEVER publish directly to a Queue in AMQP โ Producers publish to an **Exchange**, and Exchanges route copies to bound Queues (`assertExchange(..., { du...
`direct` (exact routingKey match), `fanout` (broadcast copy to ALL bound queues, e.g., `user.deleted`!), `topic` (`*` single word, `#` zero-or-more words, e.g., `ord...
Designing dot-delimited routing taxonomies `<domain>.<entity>.<event>.<region>` (`commerce.order.created.in`), matching `commerce.order.*.*` vs `commerce.#`
Using `createConfirmChannel()` (waits for broker disk persistence ack!) + checking `channel.publish()` boolean backpressure + setting **`channel.prefetch(10)`** on C...
Setting `{ noAck: false }`, calling `channel.ack(msg)` ONLY AFTER DB commit succeeds, and calling `channel.nack(msg, false, false)` (route to DLQ, NOT infinite immed...
Implementing non-blocking delayed retries in RabbitMQ using Wait Queues (`x-message-ttl: 5000`, `x-dead-letter-exchange: main.ex`) tracking retry count in `msg.prope...
Configuring `arguments: { "x-dead-letter-exchange": "orders.dlx", "x-dead-letter-routing-key": "orders.failed" }` on primary queues so rejected/expired messages land...
Why Kafka is an **immutable append-only event log** (consumers pull & advance offsets; reading a message does NOT delete it!) vs RabbitMQ queue deletion on `ack`, KR...
Multi-broker clusters, Topic retention (`retention.ms = 7 days` or `compact` log compaction keeping latest value per key), and sequential disk I/O + OS pagecache zer...
Why **ordering in Kafka is guaranteed ONLY WITHIN a single Partition** -> hashing **`key: orderId`** (`murmur2(key) % numPartitions`) ensures `OrderCreated -> OrderP...
`acks: -1` (`all` in-sync replicas `ISR` confirm!), `idempotent: true` producer sequence numbers preventing duplicate appends on network retry, and `linger.ms` / `sn...
Within ONE `groupId` (`inventory-svc-group`), each Partition is assigned to AT MOST ONE consumer instance (`12 partitions` + `4 consumers` = `3 partitions each`; `12...
`__consumer_offsets` topic, committing `offset + 1` ONLY AFTER processing + idempotent DB write succeeds (`autoCommit: false`), consumer lag monitoring (`latestOffse...
Build a fault-tolerant background processing pipeline combining `BullMQ` (exponential backoff, deterministic `jobId` deduplication, DLQ inspection, PDF invoice generation) with a `RabbitMQ` topic exchange + DLX consumer and `Kafka` partition key ordering demo.
Module Learning & Hands-On Objectives
Bidirectional low-latency use cases (chat, collaborative cursors, live bidding) vs unidirectional server-push (`SSE` for live order/ticker feeds), stateful TCP socke...
Short Polling (high wasted overhead), HTTP Long Polling (held request), Server-Sent Events (`text/event-stream`, HTTP/2 friendly one-way server->client), and WebSock...
`GET / HTTP/1.1` + `Upgrade: websocket` + `Sec-WebSocket-Key` -> `101 Switching Protocols` + `Sec-WebSocket-Accept`, lightweight binary/text frames, opcode `0x9` Pin...
Detecting half-open "zombie" TCP connections (mobile tunnel drop without FIN packet!) via `pingInterval` (`25s`) & `pingTimeout` (`20s`), and bounding `maxHttpBuffer...
What `Socket.IO` adds on top of WebSockets: automatic reconnection with backoff, packet buffering, acknowledgments (`emitWithAck`), Rooms, Namespaces, HTTP long-poll...
Attaching `new Server<ClientToServerEvents, ServerToClientEvents, InterServerEvents, SocketData>(httpServer, { cors })` onto the SAME `http.Server` as Express!
`io.on("connection", socket => ...)`, `socket.on("disconnecting")` (`socket.rooms` is STILL populated here!) vs `socket.on("disconnect", reason => ...)` (`socket.roo...
`socket.emit` (sender only), `socket.broadcast.emit` (everyone EXCEPT sender), `io.to(room).emit` (all in room), and callback/Promise acknowledgments (`socket.timeou...
Auto-joining every authenticated socket into `socket.join(\`user:\${socket.data.userId}\`)` (supports 3 open browser tabs + mobile app effortlessly!), resource rooms...
Persist-First flow: `1) Validate Zod -> 2) Authorize conversation membership -> 3) Persist message in PostgreSQL/MongoDB with clientIdempKey -> 4) Emit to user:${rec...
Channel membership rooms (`channel:${channelId}`), typing indicators (`volatile.emit` โ droppable if congested!), read-cursor watermarks (`lastReadMessageId`), and b...
Multi-device accurate presence in Redis: `SADD presence:user:${uid} ${socket.id}` on connect + `SREM` on disconnect (`user is offline ONLY when SCARD === 0`!) + hear...
Verifying `socket.handshake.auth.token` (or `HttpOnly` cookie on handshake โ NEVER `?token=jwt` in URL query string which leaks into Nginx/proxy access logs!!) insid...
Validating DB ownership inside `socket.on("order:subscribe", async ({ orderId }, ack) => { const ok = await orderSvc.canView(socket.data.userId, orderId); if (!ok) r...
Randomized reconnection jitter (`reconnectionDelay`, `randomizationFactor: 0.5` preventing `10,000` clients reconnecting at the exact same millisecond after a deploy...
Wrapping every `socket.on(...)` listener in a safe `withSocketGuard(schema, rateLimiter, handler)` because an unhandled `async` rejection inside `socket.on()` crashe...
Why scaling to `N` Node containers breaks in-memory `io.to("user:42").emit(...)` + why Socket.IO HTTP long-polling fallback requires sticky sessions (or `transports:...
Creating dedicated `pubClient` and `subClient = pubClient.duplicate()`, attaching `io.adapter(createAdapter(pubClient, subClient))` so `io.to("user:42").emit(...)` f...
End-to-end flow: Domain Service emits `OrderShipped` -> BullMQ/RabbitMQ Consumer persists `notifications` DB row (`isRead: false`) -> publishes via Redis Emitter to...
Out-of-order frame protection (`version` / sequence numbers on state updates so v2 doesnโt overwrite v3!), backpressure coalescing, and graceful socket drain on depl...
Build a JWT-authenticated `Socket.IO` server using `@socket.io/redis-adapter` across 2 Node instances, auto-joining `user:${userId}` multi-tab rooms, enforcing server-side BOLA room-subscription checks, Redis presence heartbeats, and acknowledgments.
Module Learning & Hands-On Objectives
Comparing Deployment simplicity, ACID single-DB joins, and `0ms` in-process calls (Monolith) vs Independent team/service scaling, fault isolation, and polyglot datab...
Starting new products as a strictly modularized single deployable (`modules/users`, `modules/catalog`, `modules/orders` with zero cross-schema SQL joins!) and extrac...
Independent deployability, backward-compatible API/event contracts, autonomous data ownership, and resilience when peer services are down
Splitting by **Business Capability** (`User`, `Product Catalog`, `Inventory`, `Cart`, `Order`, `Payment`, `Notification`), NOT by technical layer (`DatabaseService`,...
Why `"Product"` means `{ title, description, images, specs }` inside **Catalog Context** (`MongoDB`), `{ sku, warehouseId, qtyOnHand, reservedQty }` inside **Invento...
Choosing **Synchronous Request/Response** (`REST` / `gRPC` for immediate read queries) vs **Asynchronous Event-Driven** (`RabbitMQ` / `Kafka` for state changes & mul...
Internal HTTP clients using pooled `fetch` / `undici` keep-alive connections, mandatory `AbortSignal.timeout(3000)`, propagating `X-Correlation-Id`, and strict Zod r...
Contract-first `.proto` IDL schemas, strongly typed generated TypeScript stubs, compact binary Protobuf serialization (`3โ7x` smaller than JSON), and multiplexed HTT...
Single external entrypoint (`gateway` / `Nginx` + Gateway service) handling TLS, CORS, Edge Rate Limiting, JWT verification (forwarding verified `X-User-Id`/`X-User-...
Client-side vs Server-side discovery; how Docker Compose internal DNS (`http://inventory-svc:3003`) and container orchestrator Services resolve healthy container IPs...
Shared typed config validation pattern per service (`PORT`, `SERVICE_NAME`, `LOG_LEVEL`, own `DATABASE_URL`, `BROKER_URL`, `INTERNAL_JWT_PUBLIC_KEY`)
`user-svc` owns `users_db` (Postgres), `product-svc` owns `catalog_db` (MongoDB), `cart-svc` owns `cart_redis` (Redis), `inventory-svc` owns `inventory_db` (Postgres...
Publishing immutable past-tense **Domain Events** (`OrderCreated`, `StockReserved`, `StockInsufficient`, `PaymentSucceeded`, `PaymentFailed`) carrying `{ eventId, ev...
When RabbitMQ topic exchanges shine (task routing, flexible bindings, per-message TTL/DLQ) vs when Kafka shines (high-throughput ordered event streaming, multi-day r...
Queries needing immediate read response (`GET /cart`) -> Sync HTTP/gRPC + Cache; Cross-service multi-step state mutations (`Checkout Saga`) -> Async Events / Command...
Why cross-service `XA / 2PC` locks kill availability, AND why naive `await db.saveOrder(); await broker.publish("OrderCreated");` loses events if the process crashes...
Forward steps + **Compensating Transactions** on failure: `1) Create Order (PENDING) -> 2) Reserve Stock -> 3) Charge Payment -> [IF PAYMENT FAILS] -> Compensate: Re...
Read-your-own-writes UX, maintaining local read projections (`order-svc` listens to `ProductUpdated` or snapshots SKU summary), and handling out-of-order event arriv...
Recording `processed_events(event_id PRIMARY KEY, processed_at)` INSIDE the same local DB transaction as the consumerโs state update (`Inventory` stock deduction)!
Why synchronized fixed-interval retries (`100` callers all retrying at exact `+2.000s`, `+4.000s`) hammer a recovering service back down vs **Full Jitter** `random(0...
Tracking rolling failure rate: when downstream `payment-svc` hits `>= 5` consecutive timeouts/5xx, trip **OPEN** (fail fast in `0.1ms` for `15s` cooldown without tyi...
Propagating deadline budgets (`AbortSignal.timeout`) AND **Bulkheads** (separate connection/concurrency pools per downstream dependency so a slow `ReportingService`...
W3C `traceparent` header (`00-<traceId>-<spanId>-01`) propagating one `traceId` across HTTP calls AND RabbitMQ/Kafka message headers (`OpenTelemetry` Node SDK -> `Ja...
Generating `correlationId` at API Gateway entry, storing in `AsyncLocalStorage`, forwarding in every outbound HTTP call, Outbox row, Queue job, and Socket.IO emit!
Standardizing Pino JSON log schema (`timestamp`, `level`, `service`, `env`, `correlationId`, `userId`, `durationMs`, `msg`) written to `stdout` (`12-Factor` log rout...
Why `"itโs on the internal Docker network"` is NOT sufficient auth: validating caller identity, scoping `aud: "inventory-svc"`, network segmentation (DBs unreachable...
Signing short-lived internal tokens (`iss: "order-svc"`, `aud: "inventory-svc"`, `exp: +60s`) verified offline via `RS256`/`Ed25519` public keys (`JWKS`) โ and deliv...
When engineering orgs and domain throughput outgrow a single deployment unit, backend engineers must decompose bounded contexts cleanly without accidentally building a fragile "distributed monolith" plagued by shared DB tables, synchronous cascading timeouts, or lost domain events. Build an **E-Commerce Microservices Backend** comprising **7 independent Node.js + TypeScript services** (`User`, `Product`, `Inventory`, `Cart`, `Order`, `Payment Simulation`, and `Notification`) communicating through an API Gateway, asymmetric JWT verification, **Transactional Outbox + RabbitMQ/Kafka events**, **Saga distributed compensation**, **Redis caching**, and **BullMQ background workers**.
Module Learning & Hands-On Objectives
`node --cpu-prof dist/server.js` (or `inspector` `Profiler.start`), reading wide flat plateaus on Flamegraphs (wide bar = CPU time spent IN that function!), and `cli...
`monitorEventLoopDelay` `p50`/`p95`/`p99` (`healthy < 20ms`, `degraded > 100ms`), why high event-loop lag delays `setTimeout` timeouts, health checks, and WebSocket...
Classifying JSON serialization of 50k rows, image/PDF rendering, regex, compression, and crypto (`CPU-bound`) vs SQL/Mongo/Redis/HTTP queries (`I/O-bound`)
Auditing vulnerable nested-quantifier regexes (`/^(a+)+$/` -> `O(2^n)` CPU freeze on `"aaaaaaaaaaaaaaaaaaaaaaaaX"`!), replacing with linear regexes/`re2`/bounded str...
Taking TWO heap snapshots (`v8.writeHeapSnapshot()` at `t=1m` after warmup and `t=10m` after 10,000 requests) -> diffing `Delta > 0` allocated objects & inspecting t...
Scavenge (fast `< 2ms` nursery copy) vs Major Mark-Sweep-Compact, setting `NODE_OPTIONS="--max-old-space-size=384"` inside a `512Mi` Docker container (leaving headro...
Sizing fixed worker-thread pools (`Math.max(1, os.availableParallelism() - 1)`) with bounded input queues (`maxQueue`) rejecting with `503` on overload
Streaming `stdin`/`stdout` to external CLI tools (`pg_dump`, image/document tools) with hard `timeout`, `killSignal`, and concurrency semaphore caps
When `node:cluster` / `PM2 -i max` wins (single Linux VPS) vs when `1` single-process Node container ร `N` Docker/orchestrator replicas wins (clean per-process cgrou...
Restart backoff delays (`exp_backoff_restart_delay`), max memory restart thresholds (`max_memory_restart: "450M"` safety net while fixing leaks), and crash-loop aler...
End-to-end pool math: PostgreSQL (`connection_limit`), MongoDB (`maxPoolSize`), Redis (`ioredis`), AND Nodeโs built-in `undici` global `fetch` connection poolkeep-al...
Eliminating `SELECT *`, batching `IN (...)` lookups, pushing aggregations into SQL/Mongo, read-replica routing for heavy analytics reports, and `statement_timeout =...
Inspecting `pg_stat_user_indexes` (`idx_scan = 0` unused indexes slow down every `INSERT`/`UPDATE` and waste RAM!), covering `INCLUDE` indexes enabling `Index Only S...
Selective `brotli`/`gzip` above `1 KB` (preferring compression at **Nginx** reverse proxy so Nodeโs main thread/threadpool saves `zlib` CPU!), `ETag` `304`, and spar...
Enforcing max offset caps (`page <= 100` for classic numbered pages) + switching feeds, audit logs, and exports to `O(log N)` keyset cursors (`WHERE (created_at, id)...
Tiny bounded in-process `L1 LRU` (`max: 500` items, `TTL: 5s` for ultra-hot static config/categories -> `0.002ms` zero network!) backed by `L2 Redis` (`TTL: 5m` -> `...
Warm-up phase -> Ramp-up (`10 -> 50 -> 200 -> 500` VUs) -> Sustained plateau -> Spike test; tracking `p95`, `p99`, error rate `< 0.1%`, and finding saturation bottle...
Bounding max in-flight requests per worker, shedding excess load early with fast `503 Retry-After: 2` instead of accepting 10,000 requests that all time out after 30...
Vertical (`2 vCPU -> 8 vCPU`, simplest up to hardware ceiling, single point of failure) vs Horizontal (`N` stateless API containers across `2+` hosts behind Load Bal...
Handling keep-alive idle connections vs active in-flight requests (`server.closeIdleConnections()` in Node 18.2+!), failing `/readyz` for `3โ5s` FIRST so Nginx stops...
CRITICAL distinction: **`GET /healthz` (Liveness)** checks ONLY that the Node event loop responds (`200 OK`, NEVER queries Postgres/Redis!) vs **`GET /readyz` (Readi...
Eliminating Single Points of Failure (`SPOF`): redundant Load Balancers, `>= 2` API instances, PostgreSQL Primary + Streaming Standby Replica, MongoDB 3-node Replica...
Profile an intentionally slow/leaky Node API with `autocannon`, `--inspect` heap snapshots, and `perf_hooks.monitorEventLoopDelay()`, eliminate `O(N)` event-loop stalls via `worker_threads` + `Piscina`, tune PostgreSQL pools, and cut `p99` latency by `>= 70%`.
Module Learning & Hands-On Objectives
Structuring `/srv/backend` or `/opt/app`, `/etc/nginx/sites-available`, `/var/log/nginx`, swap sizing, and checking inode (`df -i`) as well as block (`df -h`) exhaus...
Creating dedicated unprivileged system user `useradd --system --create-home --shell /usr/sbin/nologin nodeapp`, disabling root SSH login, and scoping `sudo` strictly...
Writing `/etc/systemd/system/backend-api.service` (`Restart=on-failure`, `RestartSec=5`, `User=nodeapp`, `EnvironmentFile=/etc/backend/api.env`, `LimitNOFILE=65535`)...
`ss -tulpn`, `ip addr`, `curl -I http://127.0.0.1:3000/healthz`, `nc -zv`, and `ufw default deny incoming` allowing ONLY `22/tcp` (SSH), `80/tcp` (HTTP), and `443/tc...
Ed25519 SSH keys, `PasswordAuthentication no`, `PermitRootLogin no`, SSH bastion/port forwarding (`ssh -L 5433:127.0.0.1:5432 deploy@server` to inspect prod DB safel...
Storing `/etc/backend/api.env` (`chmod 0600`, `chown root:nodeapp` or `nodeapp:nodeapp`) outside the Git working directory so `git clean` or redeploys never touch or...
`journalctl -u backend-api --since "10 min ago"`, configuring `/etc/logrotate.d/` (`daily`, `rotate 14`, `compress`, `delaycompress`), and diagnosing high load (`top...
Raising `ulimit -n` (`nofile = 65535`, default `1024` crashes Node with `EMFILE: too many open files` at ~900 concurrent WebSockets!), `somaxconn`, and NTP time sync...
Linux kernel `namespaces` (isolated PID, net, mount, user views) + `cgroups` (CPU/RAM caps) sharing the host kernel (`~20ms` boot, near-zero overhead) vs hypervisor...
Docker CLI -> `dockerd` Daemon -> `containerd` -> `runc` OCI runtime, layered copy-on-write UnionFS image layers, and OCI registries (`GHCR` / Docker Hub)
Immutable tagged Images (`ghcr.io/org/api:git-sha`, NEVER deploy mutable `:latest` tags in production!) vs ephemeral Containers (`docker run --rm`, `docker ps`, `doc...
`FROM node:22-bookworm-slim` (avoid `alpine` `musl` libc surprises with `prisma`/`argon2`/`sharp` native binaries unless tested โ `bookworm-slim` uses standard `glib...
Running as built-in non-root `USER node` (UID `1000`), `--read-only` root filesystem (`--tmpfs /tmp`), `--cap-drop=ALL`, and resource limits (`mem_limit: 512m`, `cpu...
Named volumes (`pg_data:/var/lib/postgresql/data`, `mongo_data:/data/db`, `redis_data:/data`, `minio_data:/data`) vs bind mounts (dev only!), and NEVER running `dock...
Custom isolated Docker networks: `edge_net` (`nginx <-> api`) vs `backend_net` (`api + worker <-> postgres + mongo + redis + minio` with `internal: true` so DB conta...
Modern `compose.yaml` (`healthcheck`, `depends_on: { postgres: { condition: service_healthy } }`, `restart: unless-stopped`, `logging: { driver: "json-file", options...
Assembling the complete polyglot backend stack (`nginx`, `migrate`, `api`, `worker`, `postgres:16`, `mongo:7`, `redis:7`, `minio`) booting cleanly from cold start in...
3-stage `Dockerfile`: Stage 1 `deps` (`npm ci`) -> Stage 2 `builder` (`npx prisma generate && npm run build` + `npm prune --omit=dev`) -> Stage 3 `runtime` (copies O...
`upstream backend_api { server 127.0.0.1:3001; server 127.0.0.1:3002; keepalive 32; }`, `X-Real-IP` / `X-Forwarded-For` / `X-Forwarded-Proto`, `client_max_body_size...
`ecosystem.config.cjs` (`instances: "max"`, `exec_mode: "cluster"`, `wait_ready: true`, `listen_timeout: 8000`, `kill_timeout: 15000`), zero-downtime `pm2 reload`, `...
Configuring `A` (IPv4) & `AAAA` (IPv6) records for `api.yourdomain.com`, `CAA` records restricting certificate issuance to Letโs Encrypt, and lowering DNS `TTL` (`30...
Automating free trusted TLS 1.2/1.3 certificates via `certbot --nginx -d api.example.com`, HTTP `80 -> 301 HTTPS 443` redirect, `HSTS`, OCSP stapling, and verifying...
Authoring `.github/workflows/ci-cd.yml` with `npm ci` caching, `postgres:16` + `mongo:7` + `redis:7` GitHub Actions `services:` containers, running `lint -> typechec...
Push to `main` -> CI passes -> Build & push GHCR image (`:git-sha`) -> Deploy over SSH (`docker compose pull && docker compose run --rm migrate && docker compose up...
Exposing Prometheus `/metrics` (`prom-client`: HTTP request duration histograms by route/status, event-loop lag, active handles, heap bytes, DB pool queue), Grafana...
Automated encrypted off-host `pg_dump` + `mongodump` schedules with retention pruning, monthly restore drills, and the 6-step Incident Runbook (`Check /readyz -> Che...
Containerize and deploy a polyglot Node.js + PostgreSQL + MongoDB + Redis + MinIO + Nginx stack using a `~165 MB` 3-stage non-root `Dockerfile`, dual-network `compose.yaml` with `service_healthy` checks, `PM2` cluster config, Prometheus `/metrics`, and `.github/workflows/ci-cd.yml`.
Module Learning & Hands-On Objectives
Lexical closures & memory retainers, `this` & prototype delegation, Promise combinators (`all` vs `allSettled` vs `any`), `return await` inside `try/catch`, and exac...
`unknown` vs `any` vs `never`, discriminated unions, custom type predicates (`x is T`), `keyof`/`typeof`/`infer`, utility types (`Pick`, `Omit`, `Partial`, `Record`)...
V8 JIT & GC generations, `libuv` epoll vs 4-thread pool (`UV_THREADPOOL_SIZE`), `Buffer` & Stream backpressure (`pipeline()`), `worker_threads` vs `cluster`, and dia...
Middleware execution stack, 4-arg `(err, req, res, next)` error handler mechanics, `asyncHandler` / Express 5 Promise forwarding, `keepAliveTimeout` > proxy idle tim...
MongoDB `$match`/`$group`/`$lookup` + `ESR` compound indexes + `.lean()`, PostgreSQL Joins, `NOT EXISTS`, Window Functions (`DENSE_RANK`, `LAG`), `EXPLAIN ANALYZE`,...
Argon2id vs bcrypt, `15m` Access + `7d` rotated `HttpOnly` Refresh family reuse detection, OAuth2 PKCE + OIDC `email_verified`, RBAC + BOLA query scoping, Rate Limit...
Capacity math (`100:1` read:write), Base62 (`[0-9a-zA-Z]`, `7` chars = `62^7 = 3.5 trillion` URLs!) over Snowflake/Range-Allocated IDs (zero collision!), `302` (anal...
Multi-app OIDC/OAuth2 issuer, `Ed25519`/`RS256` key rotation via cached `/.well-known/jwks.json`, Redis rate-limit + `jti` revocation broadcast, refresh-token family...
Handling `50,000` users clicking Buy on `500` iPhones at `12:00:00`: CDN/Redis catalog cache -> Lua atomic stock pre-decrement gate (blocks 49,500 oversells in `0.2m...
Unified `POST /notify` API + Idempotency Key -> User Preference/Opt-Out filter -> Channel-isolated Priority Queues (`otp-sms` vs `promo-email`) -> Provider Adapters...
Stateful WebSocket Gateway fleet + Redis Presence/Routing Registry (`userId -> gatewayNodeId`) + Message Service + Partitioned/Time-Sorted Message Store (`(conversat...
Metadata DB (`files` table: `id`, `ownerId`, `sha256`, `status`, `size`) separated from Blob Storage (`MinIO` / Object Store): Presigned Multipart Chunked Upload (re...
Durable `scheduled_jobs` table (`next_run_at` indexed) -> Partitioned Scheduler Pollers using `SELECT ... WHERE next_run_at <= NOW() AND status = 'READY' FOR UPDATE...
API Gateway placement, Token Bucket vs Sliding-Window Counter (`curr_min * 1 + prev_min * overlap_ratio` โ `O(1)` memory using just 2 integers!), Redis Lua atomicity...
Non-blocking stdout JSON -> Shipper agent -> Kafka buffer (absorbs `10x` incident log storms!) -> Bulk indexer -> Hot (`7d` searchable) vs Cold (`90d` compressed arc...
Timed 60-min builds: (1) User Registration/Login + Rotated Refresh JWT API, (2) Validated Employee CRUD + Paginated Search/Filter/Sort API, and (3) Role + Granular P...
Timed 60-min builds: (4) Keyset Cursor + Faceted Search API, (5) Multer + Magic-Byte + Checksum File Upload & Presigned URL Service, and (6) BullMQ Templated Email N...
Timed 75-min builds: (7) Cache-Aside + Single-Flight Stampede Guard + Invalidation Layer, (8) Priority Retry + DLQ Background Job Processor, (9) HMAC-SHA256 + Timest...
Deliver architecture specs & capacity calculations for all 10 Backend System Design problems (URL Shortener, Auth/SSO, Flash-Sale Order Engine, Notification Hub, Chat, Object Storage, Job Scheduler, Rate Limiter, Log/Cache Ring) plus runnable timed Machine-Coding builds.
Module Learning & Hands-On Objectives
Structuring `src/modules/{auth, users, catalog, inventory, cart, coupons, orders, payments, notifications, uploads}` with strict TypeScript config, Composition Root...
Implementing registration, email verification, password reset, `Argon2id`, `15m` Access + `7d` rotated `HttpOnly` Refresh family reuse detection, OAuth2 fundamentals...
Modelling polymorphic Product & Category specs/attributes in **MongoDB (`Mongoose`)** with `ESR` + text indexes, alongside **PostgreSQL (`Prisma`)** Users, Inventory...
Building `GET /api/v1/products` with keyword search, category/price/rating/in-stock filters, whitelisted sorting, cursor/offset pagination, and Redis Cache-Aside + S...
Redis Hash / DB-synced Shopping Cart APIs (`add`, `updateQty`, `remove`, `clear`, live stock/price re-validation) + Coupon Engine (`PERCENTAGE` w/ `maxDiscountPaise`...
Sorted-SKU `SELECT ... FOR UPDATE` / conditional atomic `qtyOnHand >= qty` stock reservation, snapshotting `title` + `unitPricePaise` on `OrderItem`, `Idempotency-Ke...
Creating sandbox payment intents (`orderId`, `amountPaise`, `currency: "INR"`), verifying inbound `payment.captured` / `payment.failed` webhooks via `express.raw` +...
Enforcing strict legal state transitions (`PENDING_PAYMENT -> PAID -> CONFIRMED -> PACKED -> SHIPPED -> DELIVERED`, `CANCELLED`, `REFUNDED`) with audit history times...
Multer + magic-byte validation (`PNG`/`JPEG`/`WEBP` product images; `PDF` GST invoices) stored in private Dockerized `MinIO` buckets with presigned upload/download U...
Publishing `OrderPaid`, `OrderShipped`, `OrderCancelled` domain events via Outbox -> RabbitMQ/Kafka + BullMQ workers generating PDF invoices, sending transactional e...
JWT-authenticated Socket.IO (`@socket.io/redis-adapter`) pushing live `order:status_changed` events to `user:${buyerId}` and `inventory:low_stock` alerts to `/admin`...
Tiered Redis rate limiters (`/auth`, `/orders`, `/webhooks`, `/products`), `helmet`, strict `cors`, RFC-style error envelopes, Pino redacted JSON logs with `correlat...
Serving complete `/api/docs` OpenAPI 3.1 specification + exporting `postman/ecommerce-capstone.collection.json` covering Auth -> Catalog -> Cart -> Coupon -> Order -...
Unit tests (pricing, coupons, state machine, HMAC) + Real-DB Supertest integration suites (Auth rotation, Catalog search, Concurrent Stock Race, Idempotent Payment W...
Multi-stage non-root `Dockerfile`, `compose.yaml` (`nginx`, `migrate`, `api`, `worker`, `postgres`, `mongo`, `redis`, `minio`, `rabbitmq`) with healthchecks, `.env.e...
Polishing all 6 mandatory GitHub repositories (architecture diagrams, ER diagrams, benchmark tables, setup guides), completing 105 JS/TS DSA + 30 Backend Machine-Cod...
Architect, implement, secure, load-test, document, and containerize a complete, production-ready **Enterprise E-Commerce and Order Management Backend** in **TypeScript 5, Node.js 22, and Express.js**. This flagship 6-month capstone unifies polyglot persistence (**PostgreSQL 16 + Prisma** for users, RBAC, addresses, coupons, inventory reservations, orders, payments, refunds & audit logs + **MongoDB 7 + Mongoose** for hierarchical categories, brands, polymorphic product catalogs, variants & customer reviews), **Redis 7** (Cache-Aside, single-flight stampede protection, guest/user carts & Lua rate limiting), **BullMQ** (PDF/JSON invoices, transactional emails & unpaid-order expiry), **RabbitMQ / Kafka** domain event streaming with Transactional Outbox, **Socket.IO** real-time order-status notifications, **S3-compatible MinIO** presigned media storage, **Jest/Vitest + Supertest** suites, **OpenAPI 3.1 / Swagger**, and **3-Stage Non-Root Docker Compose + Nginx** vendor-neutral Linux deployment.
Verify your email OTP in 15 seconds to receive the live Zoom/Meet demo link, complete 24-module PDF, and personalized roadmap for Node.js Backend Developer โ 6-Month Industry-Ready Career Program.
JavaScript ES6+ & Async
Web LanguageStrict TypeScript 5
Typed LanguageNode.js 22 (V8 & libuv)
Backend RuntimeExpress.js & OpenAPI 3.1
HTTP API LayerMongoDB 7 & Mongoose 8
NoSQL Document DBPostgreSQL 16 & SQL
Enterprise RDBMSPrisma ORM 5 & ACID
Type-Safe ORMJWT, OAuth2, RBAC & OWASP
App & Cloud SecurityRedis 7 & BullMQ Queues
In-Memory CacheRabbitMQ, Kafka & Sagas
Event StreamingJest, Vitest & Supertest
Test AutomationLinux, Nginx & PM2
OS & Scripting3-Stage Docker Compose
ContainersGitHub Actions CI/CD
CI/CD PipelinesLeetCode Problem Solving
Trainer Coding PrepHackerRank Coding Prep
Trainer Coding PrepNode.js Backend Developer โ 6-Month Industry-Ready Career Program teaches you how modern tech companies design, build, test, and deploy reliable Node.js, TypeScript & Express Backend Engineering software using JavaScript ES6+ & Strict TypeScript 5, Node.js 22 LTS (V8, libuv & Event Loop), Buffers, Streams & Async File Processing, Express.js Layered REST Architecture, OpenAPI 3.1, Swagger UI & Zod Validation โ explained in clear everyday language before writing real production code.
Suitable for both complete beginners (guided step-by-step from Day 1 setup and core logic) and technical students/working professionals aiming for production architecture mastery.
Key Engineering Capabilities You Will Build:
Purpose: Directly required by Node.js, TypeScript & Express Backend Engineering engineering teams to ship reliable client systems.
Purpose: Directly required by Node.js, TypeScript & Express Backend Engineering engineering teams to ship reliable client systems.
Purpose: Directly required by Node.js, TypeScript & Express Backend Engineering engineering teams to ship reliable client systems.
Purpose: Directly required by Node.js, TypeScript & Express Backend Engineering engineering teams to ship reliable client systems.
Purpose: Directly required by Node.js, TypeScript & Express Backend Engineering engineering teams to ship reliable client systems.
Purpose: Directly required by Node.js, TypeScript & Express Backend Engineering engineering teams to ship reliable client systems.
Student Learning Outcomes (By End of Course):
Recommended Baseline Stack: Node.js 22 LTS, JavaScript ES2024+, TypeScript 5.x (`strict: true`), Express.js, `Zod`, OpenAPI 3.1 / Swagger, MongoDB 7 + Mongoose 8, PostgreSQL 16 + Prisma 5, `argon2`, `jose` / `jsonwebtoken`, `helmet`, `ioredis` (Redis 7), `bullmq`, `amqplib` (RabbitMQ 3), `socket.io` 4, `minio` / S3-compatible presigned storage, `vitest` / `jest` + `supertest`, `pino`, Docker Compose v2, Nginx, PM2, and GitHub Actions.Taught live by active Working IT Professionals between 7:00 AM and 8:00 PM IST (choose any slot based on trainer availability).
Batch Available (Sat โ Sun Only): 2 Hours / Day โข 7:00 AM to 8:00 PM IST (choose any slot based on trainer availability)
Mon โ Fri Guided Practice: Real GitHub repository builds, LeetCode/HackerRank coding & โฅ90% Mock/AI Interview gates.
Node.js Backend Developer (TypeScript, Express, PostgreSQL, MongoDB, Redis, BullMQ & Microservices) โ 6-Month Live Career Cohort
SatโSun Live + Weekday Guided Node.js/TypeScript Labs & DSA โข 08:00 PM โ 10:30 PM IST (25 Hrs/Week โข 600 Hrs Total)
Starts: 21 Nov 2026
๐ Live Client Production Project + Internship Letter
After completing all 24 progressive hands-on module projects during live classes, students join our mentor-led Client Production Sprint to build, test, and deploy "Enterprise E-Commerce and Order Management Backend" to live cloud production โ earning an Official Verified Internship Letter detailing their exact technical contributions.
Domain: Live Enterprise Node.js, TypeScript & Express Backend Engineering Production Engagement โข Infra: TypeScript, Node.js, Express.js, PostgreSQL + Prisma, MongoDB + Mongoose, JWT/OAuth/RBAC, Sandbox Payments & Signed Webhooks, Redis, BullMQ, RabbitMQ/Kafka, Socket.IO, Jest/Supertest, Docker Compose & Nginx
Certified on Your Official Internship Confirmation Letter:
1. Graduation Certificate
Certifies NBCP module mastery, Mock/AI Viva scores & GitHub repos.
2. Client Internship Letter
Employer BGV-verifiable proof of live production deployment contributions.
Node.js Backend Developer โ 6-Month Industry-Ready Career Program already covers 100% of the end-to-end engineering stack required for IT placement โ no “next course” is needed. Below are the 100% optional, curriculum-matched industry certifications genuinely worth taking if you want a better position and higher CTC package, backed by MockAttempt’s 100% Exam-Success Mentorship where our Working IT Professional trainers ensure you succeed in every exam.
Hands-on module projects, topic-wise MCQ mocks, AI interviews & live client internship proof.
Production architecture, performance tuning & automated testing mastery.
Accelerated when paired with the optional curriculum-matched global vendor certifications below.
Selected strictly from Node.js Backend Developer โ 6-Month Industry-Ready Career Program modules โ zero filler badges, only globally respected exams that unlock higher SDE/Architect shortlists and stronger CTC offers.
Already Taught in Your Curriculum: Semantic HTML5/WCAG, CSS Grid/Tailwind, TypeScript 5, React Hooks/Redux & Angular Signals
Why Worth Taking: Validates accessible, type-safe, tested UI engineering for global SaaS and enterprise frontend teams.
โ How We Ensure Exam Success: Machine-coding UI challenges, Vitest/Playwright test reviews & 1-on-1 Senior Frontend Architect prep.
Already Taught in Your Curriculum: Node.js Event Loop, Async Control Flow, Streams, Buffers & Automated Testing
Why Worth Taking: Live-coding Linux Foundation credential prized by high-paying SaaS unicorns and global product startups.
โ How We Ensure Exam Success: Timed Node.js coding drills, exam-environment rehearsals & 1-on-1 Senior Node.js Architect mentorship.
Already Taught in Your Curriculum: Express REST APIs, Input Validation, OWASP Security, Rate Limiting & HTTP Architecture
Why Worth Taking: Validates production HTTP service architecture, authentication hardening, and input/attack mitigation in Node.js.
โ How We Ensure Exam Success: Hands-on Express security drills, mock service scenarios & 1-on-1 Backend Architect code review.
100% Optional Choice • We Stand Behind Your Success in Every Recommended Certification Exam (FE-PRO, JSNAD, JSNSD)
Your Node.js Backend Developer โ 6-Month Industry-Ready Career Program cohort already prepares you completely for placement. If you opt in for certification mentorship to target higher MNC/GCC positions and top-band packages, our Working IT Pro trainers guide you with hands-on blueprint labs, timed mock simulators, and 1-on-1 revision until you clear every exam.
Every module, GitHub lab, 50-MCQ assessment, and 4-axis Spoken AI Viva in Node.js Backend Developer โ 6-Month Industry-Ready Career Program is reviewed quarterly against live enterprise hiring bars and taught in clear English on weekends by active Working IT Professionals.
The complete 6-month (24-week โข 600-hour) Node.js Backend Developer โ Industry-Ready Career Program is โน15,000 All-Inclusive (Incl. 18% GST โ zero hidden fees and 0% ISA salary share), payable upfront or in 3 equal 0% interest installments of โน5,000 each.
This is a dedicated backend-only engineering career program. Instead of splitting weeks across React, Angular, or CSS UI work, 100% of your 600 hours go deep into JavaScript ES6+, strict TypeScript, Node.js V8/libuv internals, Express.js REST APIs, MongoDB + Mongoose, PostgreSQL + Prisma, JWT/OAuth2/RBAC security, Redis, BullMQ, RabbitMQ/Kafka, Socket.IO, Microservices, Jest/Supertest, Linux, Docker Compose, Nginx, PM2, and GitHub Actions CI/CD.
Yes. Month 3 teaches both MongoDB + Mongoose ODM (aggregation pipelines, indexes, sessions) AND PostgreSQL 16 + Complete SQL + Prisma ORM (joins, window functions, ACID isolation, EXPLAIN plans, interactive transactions, and migrations), and you combine both in the Multi-Database Inventory Backend and Enterprise E-Commerce Capstone.
You build 6 progressive production-style backends: (1) TypeScript Employee Management CLI, (2) Production-Style Employee Management REST API, (3) Multi-Database Inventory Management Backend (MongoDB + PostgreSQL), (4) Secure Authentication & Authorization Service, (5) 7-Service E-Commerce Microservices Backend, and (6) Final Capstone: Enterprise E-Commerce & Order Management Backend.
The 6-month Coding Lab includes 135 curated TypeScript/JavaScript problems: 105 Data Structures & Algorithms problems (meeting the 100โ150 DSA requirement) plus 30 practical Backend Machine-Coding exercises covering async concurrency, REST pagination/idempotency, JWT/RBAC, caching, rate limiting, queues, and system design.
Deployment stays 100% vendor-neutral and focused on portable production backend operations without proprietary cloud lock-in: Linux server administration, SSH hardening, ufw firewall, PM2 cluster reloads, Nginx reverse proxy, Letโs Encrypt SSL/HTTPS, multi-stage Dockerfiles, multi-container Docker Compose (Node.js + PostgreSQL + MongoDB + Redis + MinIO), Prometheus health monitoring, automated backups, and GitHub Actions CI/CD.
25 hours/week across 24 weeks (~600 hours): 8h trainer-led concepts, 5h live coding, 4h guided practicals, 4h assignments, 2h DSA/interview prep, and 2h assessments/doubt clearing, with a 70% passing threshold across quizzes, coding, modules, projects, and the final capstone.
Yes. Month 1 starts from JavaScript fundamentals, variables, functions, closures, promises/async-await, complete TypeScript, Git, Linux CLI, and HTTP networking before entering Node.js runtime internals and Express.js.
Matching Career Roadmaps:
Weekend Live NBCP Cohorts Across Top IT Hiring Hubs:
Book Free Live Demo or Reserve Batch Seat