AI-Powered MERN Full Stack + TypeScript

What you will be able to do

• Write modern, typed JavaScript with async/await, modules and TypeScript
• Structure a React application with components, hooks, routing and well-chosen state management
• Design and build a versioned REST API with Express, validation and consistent error handling
• Model data in MongoDB with Mongoose, add the indexes real queries need and write aggregation pipelines
• Implement authentication and role-based authorisation, and defend against common OWASP risks
• Test the stack at unit, API and end-to-end level with Vitest, Supertest and Playwright
• Containerise the application, automate checks with GitHub Actions and deploy it
• Diagnose performance problems, add caching with Redis and debug production issues from logs

About this course

Syllabus

This syllabus is a draft awaiting instructor review. Topics, order and schedule may change before the first batch is announced.

1. 01Modern JavaScript and TypeScript+6 live sessions · 12 hours · The language foundations the rest of the course relies on: modern JavaScript, asynchronous code, modules, tooling and TypeScript.

   Learning objectives

   • Use modern JavaScript syntax confidently, including destructuring, spread, closures and array methods
   • Write and reason about asynchronous code with promises and async/await
   • Add TypeScript types, interfaces, unions and generics to everyday code
   • Set up a Node.js project with npm or pnpm, ESLint, Prettier and Git

   Live sessions

   1. 01Course setup and modern JavaScript essentials2 hInstalling Node.js, VS Code and Git; let and const, arrow functions, template literals, destructuring, spread and rest, optional chaining and nullish coalescing.
   2. 02Functions, closures, objects and arrays2 hScope and closures, this and binding, map, filter, reduce and find, immutability patterns, classes and prototypes in brief.
   3. 03Asynchronous JavaScript and the event loop2 hCallbacks, promises and async/await; the event loop, microtasks and timers; error handling in async code; fetch and Promise.all.
   4. 04Modules, packages and project tooling2 hES modules versus CommonJS, npm and pnpm, package.json scripts, semantic versioning, ESLint and Prettier, a sensible Git workflow with branches and pull requests.
   5. 05TypeScript fundamentals2 hType annotations and inference, interfaces and type aliases, union and literal types, narrowing, generics, strict mode and tsconfig essentials.
   6. 06Week 2 review and doubt-clearing2 hTyping a small existing JavaScript utility library together; common async and typing mistakes; open questions.

   Practice

   Convert a set of callback-based utilities to async/await and then to typed TypeScript, with ESLint passing.

   Assessment

   Quiz on closures, the event loop and TypeScript narrowing, plus a short typed-utilities assignment.

   You will be able to

   You can write clean, typed, asynchronous JavaScript and set up a professional project from scratch.

2. 02React architecture and hooks+6 live sessions · 12 hours · Build user interfaces from typed components, manage local state and effects, and structure a React project that stays maintainable.

   Learning objectives

   • Build typed function components with props, children and composition
   • Manage local state and side effects with useState, useEffect and useRef
   • Extract reusable logic into custom hooks
   • Organise a React project by feature and keep components small and accessible

   Live sessions

   1. 07React and Vite project setup2 hHow React renders, JSX, creating a Vite and TypeScript project, components and props, rendering lists with keys, conditional rendering.
   2. 08State, events and controlled inputs2 huseState, event handling, lifting state up, controlled inputs, derived state and why not to duplicate it.
   3. 09Effects, refs and the component lifecycle2 huseEffect and its dependency array, cleanup functions, fetching data in effects and its pitfalls, useRef for DOM access and mutable values, StrictMode double-invocation.
   4. 10Custom hooks and composition patterns2 hWriting custom hooks, composition over inheritance, children and render props, useContext for themes and session data, avoiding prop drilling.
   5. 11Project structure, styling and accessibility2 hFeature-based folder structure, CSS Modules or Tailwind CSS, semantic HTML in components, labels, focus management and keyboard operability.
   6. 12React review and doubt-clearing2 hCode review of learners’ components; refactoring a large component into smaller ones; open questions.

   Practice

   Build the course project’s batch-listing and batch-detail screens from static data, with reusable, accessible components.

   Assessment

   Project milestone 1: a typed, accessible React UI for the booking service, reviewed with feedback.

   You will be able to

   You can build a well-structured, accessible React interface with sound state and effect handling.

3. 03Routing, forms and state management+6 live sessions · 12 hours · Turn screens into an application: client-side routing, robust forms and a clear split between server state and client state.

   Learning objectives

   • Implement nested routes, route parameters and protected routes with React Router
   • Fetch, cache and update server data with TanStack Query
   • Choose where state belongs and use a small client store (Zustand) only where it helps
   • Build validated forms with React Hook Form and Zod

   Live sessions

   1. 13Client-side routing with React Router2 hRoutes, nested layouts, route and search parameters, navigation, not-found pages, lazy-loaded routes and code splitting.
   2. 14Server state with TanStack Query2 hQueries and query keys, caching and stale time, loading and error states, pagination, refetching and retries.
   3. 15Mutations and optimistic updates2 huseMutation, invalidating and updating the cache, optimistic updates and rollback, preventing duplicate submissions.
   4. 16Client state with Zustand and Context2 hServer state versus client state, when Context is enough, a Zustand store for UI state, selectors and avoiding unnecessary re-renders.
   5. 17Forms with React Hook Form and Zod2 hRegistering fields, schema validation with Zod, accessible error messages, multi-step forms, file inputs and sharing schemas with the server later.
   6. 18Front-end review and doubt-clearing2 hDebugging with React DevTools and the TanStack Query devtools; reviewing state-placement decisions; open questions.

   Practice

   Connect the booking UI to a provided mock API: routed pages, cached queries, a booking form with validation and optimistic cancellation.

   Assessment

   Quiz on routing and state placement, plus project milestone 2: a fully routed front end against the mock API.

   You will be able to

   You can build a routed React application with predictable data fetching, sensible state management and reliable forms.

4. 04Node.js and Express API design+6 live sessions · 12 hours · Design and build a clean, versioned REST API in Express with a layered structure, validation and consistent errors.

   Learning objectives

   • Explain how Node.js handles I/O and structure an Express application in layers
   • Design REST resources, status codes, pagination and versioning
   • Validate every request with Zod and return a consistent error format
   • Handle configuration, file uploads and API documentation properly

   Live sessions

   1. 19Node.js runtime and the HTTP model2 hNode.js architecture, the http module, streams and the file system, environment variables, the request-response cycle and HTTP methods and status codes.
   2. 20Express fundamentals and middleware2 hRouters, middleware order, request parsing, CORS, serving JSON, async route handlers and organising routes by resource.
   3. 21REST API design2 hResource naming, idempotency, pagination, filtering and sorting, versioning, response envelopes and documenting endpoints with OpenAPI.
   4. 22Layered architecture, validation and error handling2 hRoutes, controllers and services; validating bodies, params and queries with Zod; custom error classes; a central error-handling middleware and safe error messages.
   5. 23Configuration, file uploads and background-safe code2 hValidated configuration objects, handling multipart uploads safely, size and type limits, graceful shutdown and avoiding blocking the event loop.
   6. 24API review and doubt-clearing2 hTesting endpoints with an HTTP client; reviewing API designs against the conventions; open questions.

   Practice

   Build the booking service’s REST API with in-memory storage first, with validation, pagination and a documented error format.

   Assessment

   Assignment: an OpenAPI description and working Express API for batches and bookings, reviewed live.

   You will be able to

   You can design and build a consistent, well-validated REST API that front-end developers can rely on.

5. 05MongoDB and Mongoose+6 live sessions · 12 hours · Model data for MongoDB, query it efficiently with Mongoose, and answer reporting questions with aggregation pipelines.

   Learning objectives

   • Choose between embedding and referencing based on real access patterns
   • Define Mongoose schemas with validation, middleware and typed models
   • Create indexes for real query patterns and verify them with explain()
   • Write aggregation pipelines and use transactions where consistency requires them

   Live sessions

   1. 25Document databases and MongoDB basics2 hDocuments, collections and BSON; running MongoDB locally or on MongoDB Atlas; CRUD with the shell and Compass; query and update operators.
   2. 26Schema design for MongoDB2 hEmbedding versus referencing, one-to-many and many-to-many patterns, designing for access patterns, avoiding unbounded arrays, schema versioning.
   3. 27Mongoose models, validation and middleware2 hSchemas and typed models, built-in and custom validators, virtuals, pre and post hooks, populate and its costs, lean queries.
   4. 28Indexing and query performance2 hSingle-field, compound, multikey, text and TTL indexes; the ESR rule; reading explain() output; covered queries and index costs on writes.
   5. 29Aggregation pipelines2 h$match, $group, $project, $lookup, $unwind, $facet and $bucket; building reports step by step; aggregation performance.
   6. 30Transactions, data integrity and doubt-clearing2 hAtomic single-document updates, conditional updates to prevent double-booking, multi-document transactions and when to avoid them; open questions.

   Practice

   Move the booking API onto MongoDB, add indexes for the three most frequent queries and write a utilisation report as an aggregation pipeline.

   Assessment

   Project milestone 3: API backed by MongoDB with an index-justification note and two aggregation reports.

   You will be able to

   You can design a MongoDB data model that fits the application and keep its queries fast and correct.

6. 06Authentication, authorisation and security+6 live sessions · 12 hours · Sign users in safely, control what each role may do, and defend the application against the most common web vulnerabilities.

   Learning objectives

   • Compare server-side sessions and JWTs and choose appropriately for a given application
   • Hash passwords, manage sessions or tokens securely and implement sign-in, sign-out and password reset
   • Enforce role-based and ownership-based authorisation on the server
   • Recognise and mitigate common OWASP Top 10 risks in a MERN application

   Live sessions

   1. 31Authentication fundamentals2 hIdentification versus authentication, password hashing with bcrypt or Argon2, sign-up and sign-in flows, rate limiting and account enumeration.
   2. 32Sessions versus JWTs2 hServer-side sessions with a store, HTTP-only and SameSite cookies, access and refresh tokens, token revocation, the trade-offs and a recommendation for this project.
   3. 33Role-based access control and ownership checks2 hRoles and permissions, authorisation middleware, checking resource ownership in services, preventing insecure direct object references, protected routes in React as UX only.
   4. 34OWASP basics for MERN applications2 hInjection including NoSQL operator injection, cross-site scripting, CSRF, security headers with Helmet, CORS configuration, secrets management and dependency auditing.
   5. 35Password reset, email verification and OAuth sign-in2 hSingle-use, expiring reset tokens; email verification; signing in with an OAuth provider and what the application must still verify.
   6. 36Security review and doubt-clearing2 hReviewing the course project against an OWASP checklist; fixing findings together; open questions.

   Practice

   Add sign-in, roles and ownership checks to the booking service, then attempt a set of guided attacks against your own API and fix what succeeds.

   Assessment

   Assignment: security self-review against an OWASP checklist, with evidence that a learner cannot access another learner’s bookings.

   You will be able to

   You can add authentication and server-side authorisation to an application and close common security gaps.

7. 07Testing the stack+4 live sessions · 8 hours · Write the right tests at the right level so changes can be made with confidence.

   Learning objectives

   • Write fast unit tests for business rules with Vitest
   • Test React components the way users interact with them
   • Test API endpoints and authorisation rules with Supertest against a real test database
   • Automate a critical user journey with Playwright

   Live sessions

   1. 37Unit testing with Vitest2 hThe testing pyramid, test structure and naming, assertions, mocking and when not to mock, testing booking rules and edge cases, coverage as a guide not a target.
   2. 38Component testing with React Testing Library2 hQuerying by role and label, simulating user events, testing loading, empty and error states, mocking network requests with MSW.
   3. 39API and integration testing with Supertest2 hTesting Express routes end to end, an isolated test database, seeding and cleaning data, testing validation errors and authorisation denials.
   4. 40End-to-end testing with Playwright and doubt-clearing2 hWriting a booking journey test, locators and auto-waiting, test data setup, running accessibility checks with axe; open questions.

   Practice

   Add unit, component, API and one end-to-end test to the course project, including a regression test for a bug you fixed earlier.

   Assessment

   Quiz on test levels and mocking, plus a test-suite submission that runs green from a clean checkout.

   You will be able to

   You can build a balanced automated test suite that catches regressions across the stack.

8. 08Docker, CI/CD and deployment+4 live sessions · 8 hours · Package the application in containers, automate checks on every change and deploy it to a cloud environment.

   Learning objectives

   • Write efficient Dockerfiles and a Docker Compose setup for local development
   • Build a GitHub Actions pipeline that lints, type-checks, tests and builds
   • Deploy the front end and API with environment-specific configuration
   • Run database changes and releases without losing data

   Live sessions

   1. 41Containers and Docker2 hImages and containers, writing a multi-stage Dockerfile for Node.js, .dockerignore, image size and security basics, running as a non-root user.
   2. 42Docker Compose for local development2 hRunning the API, MongoDB and Redis together, volumes and networks, health checks and environment files.
   3. 43CI/CD with GitHub Actions2 hWorkflows, jobs and steps, caching dependencies, running lint, type checks and tests against service containers, branch protection and secrets in CI.
   4. 44Deployment and release practice2 hDeploying a static React build and a containerised API to a cloud platform, managed MongoDB, environment variables, HTTPS and custom domains, rollbacks; doubt-clearing.

   Practice

   Containerise the course project, add a CI workflow that must pass before merging, and deploy a staging environment.

   Assessment

   Project milestone 4: a deployed staging URL with a passing CI pipeline and no secrets in the repository.

   You will be able to

   You can take an application from a laptop to a repeatable, automated deployment.

9. 09Performance, caching and production operations+4 live sessions · 8 hours · Keep the application fast and diagnosable in production, and integrate an AI API responsibly as an optional advanced project.

   Learning objectives

   • Measure and improve front-end and API performance with real tools
   • Add Redis caching with a clear invalidation strategy
   • Use structured logs, request ids and error tracking to debug production issues
   • Integrate an AI API safely, with consent, cost limits and error handling

   Live sessions

   1. 45Front-end and API performance2 hCore Web Vitals and Lighthouse, bundle analysis, memoisation and list virtualisation, API response times, N+1 queries and payload size.
   2. 46Caching with Redis2 hCache-aside pattern, TTLs and invalidation, HTTP caching headers, rate limiting with Redis, what not to cache.
   3. 47Logging, monitoring and production debugging2 hStructured logging with pino, request ids, log levels and redacting personal data, error tracking, health checks, reading logs to find a real bug.
   4. 48Advanced optional project: integrating an AI API2 hCalling a large language model API from the server, keeping keys server-side, streaming responses, opt-in consent and data minimisation, timeouts, cost limits and handling wrong answers.

   Practice

   Profile the course project, fix the two slowest paths, add Redis caching to one endpoint and trace a seeded production bug from logs alone.

   Assessment

   Assignment: a short performance report with before-and-after measurements; the AI feature is an optional extension reviewed on request.

   You will be able to

   You can keep an application fast, find production problems quickly and add AI features responsibly.

10. 10Capstone project and final assessment+6 live sessions · 12 hours · Build, harden and present the capstone application, with structured reviews and the final assessment.

    Learning objectives

    • Plan a full-stack project from a written brief into a realistic scope and milestones
    • Apply the course’s architecture, security and testing practices to a new problem
    • Present and defend technical decisions in a live review

    Live sessions

    1. 49Capstone kickoff and planning2 hWalking through the brief, user stories and acceptance criteria; data model and API design; agreeing scope and milestones.
    2. 50Capstone build lab: data and API2 hGuided build time on schemas, booking rules and authorisation, with instructor support and short design check-ins.
    3. 51Capstone build lab: front end and integration2 hGuided build time on routed screens, forms and server state, with code review of work in progress.
    4. 52Capstone mid-point review2 hLive review of each project’s architecture, security and test coverage; agreeing what to fix before submission.
    5. 53Final assessment2 hWritten and practical assessment across the whole course (pass mark 60%).
    6. 54Capstone presentations and final review2 hLive project demonstrations, code walkthroughs and feedback; next steps for continued learning.

    Practice

    Build the capstone over the final weeks with weekly commits, a working deployment and an up-to-date README.

    Assessment

    Capstone project submission and live review, and the final assessment (pass mark 60%).

    You will be able to

    You can independently deliver, deploy and explain a complete, tested MERN application.

Teaching formats and fees

Every format teaches the full syllabus live, with the same projects, assessments and certificate rules. The fee is per student for the whole course.

Launch fee — GST treatment to be confirmed.

Fees are set in Indian rupees. Amounts in other currencies are estimates; the amount and currency you would pay are shown before payment once online enrolment opens.

Schedules and batches

Choose the schedule that fits your week. Both teach the same syllabus and the same 108 live hours; only the number of weeks differs.

• Weekday Intensive classes are one hour, so each 2 h syllabus session is taught across consecutive weekday classes.
• Weekend Evening classes run on Saturday and Sunday evenings; the exact time and time zone are set before a batch is confirmed.
• Public holidays are not class days unless the instructor confirms a class. Holidays, instructor leave and cancelled classes move the end date later so no live hours are lost.
• Plan about 6 hours a week of exercises, assignments and project work outside class.
• Group, Duo and One-to-One courses all follow one of these two schedules.

Final project

Certificate

Tools and skills

Where these skills apply

• Full-stack web application development
• Building and maintaining REST APIs and backend services
• Front-end development with React
• Internal tools and dashboards for businesses
• Freelance and small-team product development
• Maintaining and modernising existing JavaScript codebases

We help you prepare for work; we do not guarantee jobs, placements or salaries. Career resources

Questions about AI-Powered MERN Full Stack + TypeScript