Full-Stack MERN (NodeJS + Next.js) Training in Islamabad

🟩 Node.js + Next.js

Currently available in Islamabad

---

JavaScript on both the server and the client is the most productive full-stack setup available today — and Node.js + Next.js is the most mature, most widely deployed expression of that idea. The combination powers Vercel, Linear, Notion, Shopify Storefront, and thousands of SaaS products and enterprise applications across the world. It is the stack that modern product companies default to when they want to ship fast without sacrificing quality.

This course replaces the outdated MERN stack pattern — MongoDB-first, plain React, no TypeScript discipline — with the architecture that professional teams actually use in 2025: Node.js and Express on the backend with TypeScript, PostgreSQL with Prisma ORM for a type-safe data layer, and Next.js 15 (App Router) on the frontend. You will build a real production application across both layers, with proper testing, observability, and deployment from day one.

💡 Why Node.js + Next.js in 2025

---

• Full-stack TypeScript: one language, one type system, shared types between backend and frontend — no translation layer, no type mismatches between API and UI
• Next.js 15 App Router with React Server Components is the most significant shift in frontend architecture since hooks — and it is now stable and production-proven
• Prisma ORM gives you auto-generated TypeScript types from your database schema — the database becomes type-safe end-to-end
• Node.js's non-blocking I/O model handles thousands of concurrent connections efficiently — ideal for real-time features, streaming, and high-concurrency APIs
• The npm ecosystem is the largest package registry in existence — more integrations, libraries, and tooling than any other platform
• The most in-demand JavaScript stack for remote work: the combination of Next.js, Node.js, TypeScript, and Prisma appears in the majority of modern full-stack job postings
• Shared code between server and client: validation schemas (Zod), types, utilities, and constants live once and are used everywhere

📚 Module Breakdown

---

Week 1 — Phase 0: TypeScript & Node.js Engineering Foundations

TypeScript is the foundation of everything in this course. This phase is not "TypeScript basics" — it covers the type system features and Node.js platform knowledge that production full-stack applications depend on.

1. TypeScript strict mode: enabling all strict flags and understanding what each one enforces
2. Type inference: letting TypeScript infer types correctly — when to annotate and when to let inference do the work
3. Union types, intersection types, discriminated unions, and type narrowing: the patterns that make TypeScript useful in real code
4. Generics in depth: writing generic functions, generic interfaces, generic classes, and constrained generics
5. Utility types: Partial, Required, Pick, Omit, Record, Exclude, Extract, ReturnType, Parameters, and Awaited
6. Template literal types and conditional types: advanced type manipulation for building expressive type-safe APIs
7. Declaration merging and module augmentation: extending third-party library types
8. Zod: runtime schema validation with inferred TypeScript types — the standard for validating untrusted data at system boundaries
9. Node.js architecture: the event loop, libuv, the call stack, the task queue, and microtask queue — understanding non-blocking I/O
10. Node.js streams: Readable, Writable, Transform, and Duplex streams — processing large data without loading it all into memory
11. Worker threads: CPU-bound work in Node.js without blocking the event loop
12. Node.js built-in modules: fs/promises, path, crypto, os, child_process, and cluster
13. Modern tooling: tsx for TypeScript execution, tsup for bundling, Vitest for testing, and ESLint with typescript-eslint
14. Monorepo setup with pnpm workspaces: sharing TypeScript types, Zod schemas, and utilities between the Node.js backend and Next.js frontend
15. Environment variable management: dotenv, t3-env for type-safe environment variables validated at startup

Week 1–2 — Phase 1: Node.js Backend with Express & Fastify

Both major Node.js web frameworks are covered — Express for its ubiquity and ecosystem size, and Fastify for its schema-first, high-performance approach. Production API patterns are taught with TypeScript throughout.

Express with TypeScript:

1. Express architecture: request, response, middleware chain, Router, and the application lifecycle
2. Typed request and response: using TypeScript generics with express.Request and express.Response
3. Routing: route parameters, query strings, route groups with express.Router, and controller organisation
4. Middleware: writing typed middleware, error-handling middleware, and the middleware execution order
5. Request validation with Zod: validating body, params, and query with a reusable validateRequest middleware
6. Global error handling: the 4-argument error middleware, AppError class, and consistent error response shape
7. express-async-errors: eliminating try-catch boilerplate in async route handlers

Fastify with TypeScript:

1. Fastify architecture: schema-first design, the plugin system, decorators, and hooks
2. JSON Schema validation: defining request and response schemas — Fastify validates and serialises automatically
3. Fastify plugins: the encapsulation model — scoping routes, plugins, and hooks to sub-contexts
4. TypeBox: TypeScript-first JSON Schema builder that gives compile-time and runtime type safety together
5. Fastify vs Express: when to choose each — throughput benchmarks, ecosystem maturity, and team familiarity

Production API patterns (framework-agnostic):

1. Project structure: feature-based folder organisation — routes, controllers, services, repositories, and domain types per feature
2. Dependency injection in Node.js: constructor injection, tsyringe for lightweight DI, and manual composition root patterns
3. Configuration management: type-safe configuration with t3-env or convict — validating all environment variables at startup
4. Authentication: JWT access tokens and refresh tokens — signing, verifying, rotating, and revoking
5. Password hashing with bcrypt and Argon2: implementation and the security trade-offs between them
6. Role-based access control: permission middleware, resource ownership checks, and policy-based authorisation
7. Rate limiting: express-rate-limit and @fastify/rate-limit — per-IP, per-user, and sliding window strategies
8. CORS: configuration for Next.js SPA clients, preflight handling, and credential requests
9. HTTP security headers: helmet for Express and @fastify/helmet — CSP, HSTS, and X-Frame-Options
10. File uploads: multipart form handling with multer (Express) or @fastify/multipart, streaming to S3
11. Email: sending transactional email with Nodemailer and Resend from Node.js
12. Graceful shutdown: draining in-flight requests and closing database connections on SIGTERM
13. OpenAPI documentation: generating Swagger docs from Zod schemas with zod-to-openapi or from Fastify schemas automatically
14. API versioning: URI prefix versioning and managing multiple API versions in one codebase
15. Integration testing with Supertest and Vitest: testing the full HTTP stack with a real database via testcontainers

Week 2 — Phase 2: Database Layer — Prisma, PostgreSQL & Redis

Prisma transforms the database experience in TypeScript — your schema becomes the source of truth for both the database structure and the TypeScript types. This phase covers Prisma in production depth, alongside Redis for caching and real-time use cases.

Prisma ORM in depth:

1. Prisma architecture: schema.prisma, the Prisma Client, Prisma Migrate, and Prisma Studio
2. Schema definition: models, fields, scalar types, enums, and the @id, @unique, @default, @relation directives
3. Relations: one-to-one, one-to-many, many-to-many (explicit and implicit), and self-referential relations
4. Prisma Migrate: dev migrations, production migration workflow with prisma migrate deploy, and migration squashing
5. Prisma Client CRUD: findUnique, findFirst, findMany, create, createMany, update, updateMany, upsert, delete, deleteMany
6. Filtering and sorting: where clauses, nested filters, full-text search with PostgreSQL, and orderBy with multiple fields
7. Pagination: cursor-based pagination with take/skip/cursor — the production pattern for large datasets
8. Select and include: fetching only needed fields, including relations, and avoiding over-fetching
9. Transactions: prisma.$transaction() for interactive transactions and batch transactions
10. Prisma middleware and extensions: logging queries, soft deletes, automatic timestamps, and row-level security
11. Raw SQL with Prisma: prisma.$queryRaw and prisma.$executeRaw with parameterised queries for complex queries
12. Connection pooling: PgBouncer and Prisma Accelerate for serverless connection management
13. Prisma with PostgreSQL-specific features: JSON fields, array types, and full-text search vectors
14. Drizzle ORM as an alternative: the lightweight, SQL-first TypeScript ORM — when it is a better fit than Prisma

Redis with ioredis:

1. Redis data structures from Node.js: strings, hashes, lists, sets, sorted sets, and streams
2. Caching patterns: cache-aside, write-through, and TTL-based invalidation in Express middleware
3. Session storage: storing Express sessions in Redis with connect-redis
4. Pub/sub with Redis: real-time messaging between Node.js processes — horizontal scaling of WebSocket connections
5. Distributed locking with Redlock: preventing race conditions in distributed Node.js deployments
6. BullMQ: the production job queue for Node.js — workers, queues, delayed jobs, job priorities, and the BullMQ Board dashboard

Week 2–3 — Phase 3: Next.js 15 — App Router, Server Components & Full-Stack Patterns

Next.js 15 with the App Router represents the most significant architectural shift in React's history. React Server Components change the fundamental model of how components render, where data fetching happens, and what gets sent to the browser. This phase teaches App Router correctly — not as a migration from Pages Router, but as its own coherent architecture.

App Router fundamentals:

1. App Router vs Pages Router: the architectural difference — server-first rendering vs client-first rendering
2. React Server Components (RSC): components that render on the server and never ship JavaScript to the browser — data fetching, database access, and secrets in server components
3. Client components: the "use client" directive, when components need interactivity, and the boundary between server and client
4. The component model: server components can render client components, but not vice versa — understanding the composition rules
5. File system routing: page.tsx, layout.tsx, loading.tsx, error.tsx, not-found.tsx, and route.ts — every special file and its purpose
6. Nested layouts: persistent UI across route segments — sidebar navigation, dashboard shells, and authentication wrappers
7. Route groups: organising routes without affecting URL structure — (auth), (dashboard), (marketing) patterns
8. Parallel routes and intercepting routes: advanced layout patterns — modal routes, split views, and conditional rendering
9. Dynamic routes: [id], [...slug], and [[...slug]] — optional catch-all routes and generateStaticParams

Data fetching and caching:

1. Data fetching in server components: async/await directly in components — no useEffect, no loading state boilerplate
2. Next.js fetch cache: the extended fetch API with cache options — force-cache, no-store, and revalidate
3. React cache(): deduplicating identical requests within a single render pass
4. unstable_cache: caching the result of any async function — database queries, external API calls
5. On-demand revalidation: revalidatePath() and revalidateTag() for invalidating cached data on mutations
6. Streaming with Suspense: streaming server-rendered HTML to the browser as it becomes available — skeleton UIs while data loads
7. TanStack Query in Next.js: client-side data fetching, caching, and optimistic updates for interactive features

Server Actions:

1. Server Actions: calling server-side functions directly from client components and forms — no API endpoint needed
2. Form handling with Server Actions: the native form action pattern — progressive enhancement and no JavaScript fallback
3. useActionState: managing Server Action state (pending, result, error) in client components
4. useOptimistic: optimistic UI updates that revert if the Server Action fails
5. Server Action security: authentication checks, input validation with Zod, and CSRF protection
6. Revalidating after mutations: calling revalidatePath() and revalidateTag() inside Server Actions
7. When to use Server Actions vs REST API: the decision framework — same-origin vs cross-origin, mobile clients, and team conventions

Authentication and middleware:

1. NextAuth.js v5 (Auth.js): the standard authentication library for Next.js — providers, adapters, sessions, and JWT
2. NextAuth.js with the Node.js backend: using the Express JWT API as the credentials provider
3. Next.js Middleware: running code at the edge before requests — authentication guards, redirects, and A/B testing
4. Protected routes: redirecting unauthenticated users in middleware, layout components, and server components
5. Role-based UI: rendering different content based on session roles — server-side and client-side approaches

UI, forms, and performance:

1. Tailwind CSS v4: utility-first styling, the new CSS-based configuration, component variants with cva()
2. shadcn/ui: copy-paste, accessible, unstyled components built on Radix UI — the standard Next.js component library
3. React Hook Form with Zod: client-side form validation with shared Zod schemas from the monorepo
4. TanStack Table: server-side sorted, filtered, and paginated data tables from the Node.js API
5. next/image: automatic image optimisation, lazy loading, and WebP conversion
6. next/font: self-hosted fonts with zero layout shift
7. Metadata API: dynamic SEO metadata from server components — title templates, Open Graph, and Twitter cards
8. Bundle analysis: @next/bundle-analyzer for identifying large dependencies and code-splitting opportunities

Week 3–4 — Phase 4: Real-Time, Background Jobs & Advanced Patterns

Production applications need more than request-response cycles. This phase covers WebSockets for real-time features, BullMQ for background job processing, and the advanced Node.js patterns that high-traffic applications require.

Real-time with WebSockets and SSE:

1. WebSockets in Node.js: the ws library — server setup, connection management, message handling, and heartbeats
2. Socket.IO: rooms, namespaces, acknowledgements, and horizontal scaling with Redis adapter
3. Server-Sent Events (SSE): unidirectional server-to-client streaming — simpler than WebSockets for one-way real-time updates
4. Real-time from Next.js: consuming WebSocket connections and SSE streams in client components
5. Presence and collaboration features: tracking connected users and broadcasting state changes

Background jobs with BullMQ:

1. BullMQ architecture: queues, workers, jobs, and the Redis-backed persistence model
2. Job types: immediate jobs, delayed jobs, repeating jobs (cron), and prioritised jobs
3. Concurrency control: limiting parallel job execution per worker and across multiple workers
4. Job retries and backoff: exponential backoff, max attempts, and the failed job lifecycle
5. Job progress: reporting and tracking job progress for long-running tasks
6. BullMQ flows: parent-child job relationships for complex multi-step workflows
7. BullMQ Board: the dashboard for monitoring queue health, job history, and worker status

Advanced Node.js patterns:

1. tRPC: end-to-end type-safe APIs without code generation — defining procedures, routers, and context
2. tRPC with Next.js App Router: server-side calling, client-side with TanStack Query, and React Server Components integration
3. GraphQL with Node.js: Pothos for code-first schema building, Yoga server, and DataLoader for N+1 prevention
4. Event-driven architecture in Node.js: EventEmitter patterns, domain events, and the EventBus abstraction
5. Kafka with kafkajs: producers, consumers, consumer groups, and exactly-once semantics in Node.js
6. CQRS in Node.js: separating read models from write models — practical implementation without over-engineering

Week 4–5 — Phase 5: Testing, Observability & Production Readiness

The final phase covers a comprehensive testing strategy across both layers, the observability stack for production debugging, and everything needed to run a Node.js + Next.js application reliably at scale.

Testing strategy:

1. Vitest: the Vite-native test runner — fast, Jest-compatible, and first-class TypeScript support
2. Unit testing: testing services, utilities, and business logic in isolation with mocked dependencies
3. Integration testing: testing Express/Fastify routes with Supertest against a real PostgreSQL database via testcontainers-node
4. Testing Prisma: seeding a test database, resetting between tests, and isolating test state
5. Testing Next.js Server Components: React's new testing utilities for server components with MSW for mocking fetch
6. Testing Next.js Client Components: React Testing Library with userEvent for interaction testing
7. Testing Server Actions: calling Server Actions directly in tests and asserting database state
8. End-to-end testing with Playwright: full browser automation — login flows, form submissions, and critical user journeys
9. MSW (Mock Service Worker): intercepting API requests in both browser and Node.js test environments
10. Test coverage: generating coverage reports and setting meaningful coverage thresholds in CI

Observability:

1. Structured logging with Pino: the fastest Node.js logger — JSON output, log levels, child loggers, and request context
2. Request logging middleware: automatic request/response logging with timing, status codes, and correlation IDs
3. OpenTelemetry Node.js SDK: automatic instrumentation for Express/Fastify, Prisma, and HTTP clients
4. Distributed tracing: propagating trace context across microservices and Next.js frontend calls
5. Prometheus metrics with prom-client: custom counters, gauges, histograms, and the /metrics endpoint
6. Next.js OpenTelemetry integration: tracing Next.js App Router request cycles with the instrumentation.ts hook
7. Error tracking with Sentry: capturing unhandled errors, performance traces, and session replays in both Node.js and Next.js

Performance and production hardening:

1. Node.js cluster mode: utilising all CPU cores with the cluster module and PM2
2. Memory leak detection: identifying leaks with --inspect, Chrome DevTools heap snapshots, and clinic.js
3. Response compression: gzip and Brotli compression in Express and Fastify
4. Database query optimisation: using EXPLAIN ANALYZE in PostgreSQL, Prisma query logging, and identifying slow queries
5. Next.js performance: Core Web Vitals, Lighthouse CI, and the Next.js Speed Insights integration
6. Docker for Node.js: multi-stage Dockerfiles with non-root users, health checks, and minimal production images
7. Docker Compose: full local stack — Node.js API, Next.js, PostgreSQL, Redis, and BullMQ Board
8. GitHub Actions CI/CD: TypeScript typecheck, ESLint, Vitest, Playwright, Docker build, and deployment pipeline

---

🔌 Optional Add-On Modules

(2 weeks each — additional fee per module. Can be taken individually or combined.)

---

Add-On 1: AWS Deployment Track

Deploy Node.js and Next.js across the full AWS ecosystem — from serverless Lambda functions to containerised ECS services, with managed databases, queues, and CDN delivery.

1. AWS Lambda with Node.js: the Node.js 20.x runtime, handler patterns, cold start mitigation, and bundling with esbuild
2. Next.js on AWS Lambda: deploying Next.js with the OpenNext adapter — full App Router support on Lambda + CloudFront
3. AWS API Gateway: HTTP API integration with Lambda — routing, CORS, and custom authorisers
4. ECS Fargate: containerised Node.js Express/Fastify API — task definitions, service auto-scaling, and blue/green deployments
5. Next.js on ECS: self-hosting the Next.js server on Fargate when OpenNext is not sufficient
6. AWS RDS (PostgreSQL): managed database — connection string configuration, Prisma Migrate in production, and RDS Proxy for Lambda connection pooling
7. ElastiCache (Redis): managed Redis for BullMQ, session storage, and Socket.IO scaling adapter
8. Amazon SQS: BullMQ alternative for serverless architectures — SQS consumer in Lambda
9. AWS S3: file storage with the AWS SDK v3 — presigned uploads, CloudFront CDN for public assets
10. AWS SES: transactional email from Nodemailer and Resend via SES
11. AWS Secrets Manager: injecting secrets into ECS tasks and Lambda functions
12. CloudFront: CDN for Next.js static assets and API caching — cache invalidation on deploy
13. Infrastructure as Code with AWS CDK (TypeScript): provisioning the entire stack in TypeScript — the most natural IaC experience for Node.js teams
14. GitHub Actions: build, test, push to ECR, deploy to ECS or Lambda on merge — full CI/CD automation
15. CloudWatch: structured Pino log ingestion, custom metrics, and alarms for error rates and queue depth

Add-On 2: Google Cloud Deployment Track

Deploy Node.js and Next.js on Google Cloud Platform — with Cloud Run as the primary platform for its clean serverless container model and tight integration with GCP services.

1. Cloud Run with Node.js: containerised Express/Fastify on Cloud Run — scale-to-zero, traffic splitting, and revision management
2. Next.js on Cloud Run: deploying the Next.js server as a container on Cloud Run
3. Cloud Run Jobs: running BullMQ workers and scheduled Node.js tasks as Cloud Run Jobs
4. Cloud SQL (PostgreSQL): managed PostgreSQL — Cloud SQL Auth Proxy for secure connections, Prisma configuration
5. Memorystore (Redis): managed Redis for BullMQ and Socket.IO Redis adapter
6. Cloud Storage: file storage from Node.js using the Google Cloud Storage client library
7. Cloud Tasks: serverless task queue for background processing without a persistent Redis queue
8. Cloud Pub/Sub: event-driven messaging between Node.js services on GCP
9. Firebase with Node.js: Firestore for real-time data, Firebase Auth from the Admin SDK, and Firebase Cloud Messaging for push notifications
10. Secret Manager: loading secrets into Cloud Run services at runtime
11. Artifact Registry: building and storing Node.js Docker images
12. Cloud Build: CI/CD — typecheck, test, build, push, and deploy to Cloud Run
13. Terraform on GCP: provisioning Cloud Run, Cloud SQL, Memorystore, and Pub/Sub with reusable modules
14. Cloud Monitoring: Pino structured logs, custom OpenTelemetry metrics, and uptime checks

Add-On 3: Azure Deployment Track

Deploy Node.js and Next.js on Microsoft Azure — relevant for engineers working with enterprise clients in the Microsoft ecosystem or teams already standardised on Azure.

1. Azure Container Apps: serverless containers for Node.js Express and Next.js — scale rules, Dapr sidecar integration
2. Azure App Service for Node.js: PaaS deployment — deployment slots, auto-scaling, and ZIP deploy
3. Azure Functions with Node.js: serverless event-driven functions — HTTP triggers, timer triggers, and Service Bus triggers
4. Azure Database for PostgreSQL: managed PostgreSQL — Prisma configuration and connection security
5. Azure Cache for Redis: managed Redis for BullMQ, caching, and Socket.IO adapter
6. Azure Service Bus: message queuing for Node.js microservices — queues, topics, and subscriptions
7. Azure Event Hubs with Node.js: high-throughput event streaming — Kafka-compatible protocol support
8. Azure Blob Storage: file storage from Node.js using the Azure SDK
9. Azure Static Web Apps: deploying Next.js as a hybrid static/server app with Azure's Next.js runtime
10. Azure API Management: API gateway for Node.js APIs — rate limiting, transformation, and developer portal
11. Azure Key Vault with Managed Identity: zero-secret deployments for Node.js services
12. Infrastructure with Bicep: provisioning Container Apps, databases, Service Bus, and storage
13. Azure DevOps Pipelines: CI/CD for Node.js and Next.js — build, test, push to ACR, and deploy
14. Azure Monitor and Application Insights: OpenTelemetry integration, distributed traces, and performance dashboards

Add-On 4: SaaS & Monetisation Track

Node.js and Next.js are the most popular stack for building SaaS products — the combination of TypeScript end-to-end, Server Actions for fast form handling, and the rich npm ecosystem for payments and billing makes it the default choice. This add-on covers everything needed to ship a commercial SaaS product.

1. SaaS architecture: multi-tenancy patterns in Node.js + Prisma — row-level isolation with tenantId, schema-per-tenant, and database-per-tenant
2. Subdomain routing in Next.js: identifying tenants by subdomain using Next.js Middleware and wildcard domains on Vercel
3. Stripe integration with Node.js: the Stripe Node.js SDK — customers, products, prices, and one-time payments
4. Subscription billing with Stripe: Checkout Sessions, Customer Portal, subscription lifecycle management
5. Stripe webhooks in Node.js: handling payment_intent.succeeded, customer.subscription.updated, and invoice.payment_failed reliably with idempotency keys
6. Usage-based billing: reporting usage to Stripe Meter and billing customers for metered consumption
7. Feature flags and plan gating: restricting access to features based on the current subscription plan
8. Trial periods: 14-day trials, trial expiry flows, and conversion email sequences
9. Team and organisation models: inviting members, roles within a team, and billing at the organisation level
10. User impersonation: support staff logging in as a customer for debugging — with audit trail
11. Onboarding flows: multi-step onboarding with Server Actions and Next.js routing — persisting incomplete state
12. Admin dashboard: system metrics, user management, and billing overview built with Server Components and TanStack Table
13. Dunning management: automated retry logic, payment failure emails, and subscription pause/cancel flows
14. Analytics and metrics: tracking user activity, feature usage, and MRR with a Prisma-backed analytics schema

Add-On 5: AI Integration Track

Node.js and Next.js are first-class platforms for AI-powered applications — the Vercel AI SDK is built specifically for this stack, and the TypeScript ecosystem provides the best tooling for working with LLM APIs in a type-safe way.

1. Vercel AI SDK: the standard AI SDK for Node.js and Next.js — unified interface for OpenAI, Anthropic, Google, and open-source models
2. streamText and generateText: generating and streaming LLM responses in Node.js route handlers and Next.js Server Actions
3. useChat and useCompletion: the Vercel AI SDK React hooks for building streaming chat UIs with minimal boilerplate
4. Structured output with generateObject: forcing LLMs to return typed objects validated by Zod schemas
5. OpenAI Node.js SDK: direct API access for cases beyond the Vercel AI SDK — Assistants API, Batch API, and fine-tuning
6. Anthropic SDK for Node.js: Claude API access — tool use, extended thinking, and vision
7. Tool calling in Node.js: defining tools with Zod schemas, executing tool calls, and returning results to the model
8. LLM agents with the AI SDK: multi-step reasoning loops, tool orchestration, and max steps control
9. Embeddings in Node.js: generating embeddings with the Vercel AI SDK and storing in PostgreSQL with pgvector
10. pgvector with Prisma: the prisma-pgvector extension for vector similarity search — storing embeddings in Prisma models
11. RAG pipeline in Node.js: document ingestion, chunking, embedding generation, pgvector storage, and retrieval as Express middleware and BullMQ jobs
12. Pinecone Node.js client: integrating a managed vector database for larger-scale RAG deployments
13. Semantic caching with Redis: caching LLM responses for semantically similar queries to reduce cost and latency
14. AI features in Next.js Server Actions: calling LLM APIs from Server Actions — streaming to the UI, storing results in the database
15. Rate limiting and cost control: per-user token budgets, spend tracking in Prisma, and circuit breakers for LLM calls
16. AI evaluation with the AI SDK: testing LLM output quality, regression testing prompts, and CI integration

Add-On 6: Microservices & Event-Driven Architecture Track

Scale beyond the monolith — this add-on covers decomposing a Node.js application into independently deployable services that communicate through events, with the tooling to operate them reliably.

1. Microservice decomposition: identifying service boundaries in a Node.js monolith — strangler fig pattern and incremental extraction
2. Service communication: synchronous (HTTP/tRPC/gRPC) vs asynchronous (Kafka/RabbitMQ) — decision framework
3. gRPC with Node.js: @grpc/grpc-js, protobuf definitions with @bufbuild/buf, and generated TypeScript clients with ts-proto
4. tRPC across services: using tRPC for inter-service communication with full type safety — no code generation
5. Kafka with kafkajs: producers, consumer groups, exactly-once semantics, schema registry with Avro
6. RabbitMQ with amqplib: exchanges, queues, bindings, acknowledgements, and dead-letter queues
7. Transactional outbox pattern in Node.js + Prisma: reliably publishing events after database commits
8. API Gateway with Node.js: building a custom gateway with Express or using NGINX — routing, auth, and rate limiting
9. Service discovery: static configuration vs DNS-based discovery vs service mesh (Consul)
10. Distributed tracing across services: OpenTelemetry trace context propagation over HTTP and Kafka
11. Circuit breaker and retry with Polly for JS (cockatiel): resilience patterns for inter-service HTTP calls
12. NX monorepo: managing multiple Node.js microservices and the Next.js frontend in a single repository with shared libraries
13. Contract testing with Pact: ensuring API compatibility between services without end-to-end tests

📅 Schedule & Timings

Choose one group only based on your availability. Max 5 candidates per group to ensure individual attention and hands-on support.

Weekday Groups:

• Group 1: Mon–Wed, 10 AM – 1 PM
• Group 2: Mon–Wed, 4 PM – 7 PM

Weekend Groups:

• Group 3: Sat & Sun, 10 AM – 2 PM
• Group 4: Sat & Sun, 4 PM – 8 PM

📍 Location: In-house training in Islamabad
📱 Online option may be arranged for out-of-city participants

🛠️ Core Tools & Technologies

• Runtime: Node.js 22 LTS, TypeScript 5 strict mode
• Backend Frameworks: Express, Fastify
• ORM & Database: Prisma ORM, Drizzle ORM (reference), PostgreSQL, Redis (ioredis)
• Validation: Zod, t3-env
• Background Jobs: BullMQ, node-cron
• Real-time: Socket.IO, ws, Server-Sent Events
• Frontend: Next.js 15 App Router, React 19, TypeScript, Tailwind CSS v4, shadcn/ui, TanStack Query, TanStack Table, React Hook Form, NextAuth.js v5
• API Layer: tRPC, REST, GraphQL (Pothos + Yoga)
• Testing: Vitest, Supertest, React Testing Library, Playwright, MSW, testcontainers-node
• Observability: Pino, OpenTelemetry Node.js SDK, prom-client, Sentry
• DevOps: Docker (multi-stage), Docker Compose, GitHub Actions, pnpm workspaces
• Tooling: ESLint (typescript-eslint), Prettier, Husky, lint-staged, tsx, tsup

✅ Prerequisites

• Comfortable with JavaScript (ES2020+ — async/await, destructuring, modules)
• Basic understanding of how HTTP and REST APIs work
• Familiar with SQL basics and relational database concepts
• Basic React knowledge helpful but not required for the Next.js section
• No prior TypeScript or Node.js experience required

🎯 Who This Is For

• JavaScript developers who want to build full-stack applications properly with TypeScript
• MERN stack developers who want to modernise to the current industry standard
• Frontend developers who want to own the backend layer with the same language they already know
• Engineers targeting remote full-stack roles at product companies and SaaS startups
• Developers who want to build and ship their own SaaS products

💳 Course Fee & Booking

• ⌛ Core Program Duration: 5 Weeks
• ➕ Each Add-On Module: 2 additional weeks (additional fee per module)
• 📦 Available Add-Ons: AWS Deployment · Google Cloud · Azure · SaaS & Monetisation · AI Integration · Microservices & Event-Driven
• 🔒 Seats: 5 only per group

👉 Click here to book via WhatsApp