Full-Stack MERN Development Track

Every project below is yours to keep and to show. By the end you have a portfolio, not a certificate alone.

31 modules · 244 lessons. Open any module to see what is inside it.

1. 01 The Launch Introduction and Setup Beginner 7 lessons 4 hours

   Before any code, a clear picture of what you are about to build and what each piece does. You learn what actually happens between a browser and a server, why Node.js changed what JavaScript could do, and you finish with a development environment that

   • Node.js
   • NPM
   • Git
   • VS Code

   • What full-stack development actually means
   • What Node.js is and how it works
   • Client and server: who does what
   • Installing the toolkit: VS Code, Node.js, NPM
   • Git and GitHub: your first repository
   • Setting up a development environment that stays out of your way
   • and 1 more

   Open course
2. 02 The Foundation Frontend Foundation: HTML and CSS Beginner 12 lessons 14 hours

   The two languages every browser renders, taught as a system rather than a list of properties. You write markup that describes meaning, then lay it out with Flexbox and Grid so it holds at any width — and you learn accessibility here, at the start, wh

   • HTML5
   • CSS3
   • Flexbox
   • Grid
   • Responsive
   • Accessibility

   • How the browser turns HTML into a page
   • Semantic HTML: headings, sections, landmarks
   • Forms, inputs and native validation
   • Images, media and loading them responsibly
   • CSS selectors, the cascade and specificity
   • The box model, sizing and spacing
   • and 6 more

   Open course
3. 03 The Language JavaScript Fundamentals Beginner 12 lessons 14 hours

   The language that runs everything else in this track — on the page, on the server, and in the build tools. You cover the fundamentals properly and slowly, because every module after this one assumes you did.

   • JavaScript
   • DOM
   • Events
   • ES6

   • Variables, types and the ones that surprise you
   • Operators, conditionals and control flow
   • Loops and iteration patterns
   • Functions, parameters and return values
   • Arrays: map, filter, reduce and friends
   • Objects, destructuring and spread
   • and 6 more

   Open course
4. 04 The Depth Advanced JavaScript Intermediate 11 lessons 12 hours

   The parts of JavaScript that trip people up in their second year: closures, the event loop, prototypes, and what is really happening while you wait for a network call. This is the module that turns someone who can follow a tutorial into someone who c

   • ES6+
   • Async
   • Promises
   • Fetch
   • Modules
   • OOP

   • Scope, hoisting and closures
   • this, call, apply and bind
   • Prototypes, classes and inheritance
   • The event loop, the call stack and the queue
   • Callbacks, promises and chaining
   • async/await and running work in parallel
   • and 5 more

   Open course
5. 05 The Shortcut Bootstrap Beginner 7 lessons 6 hours

   The framework you will meet on every legacy project and most client briefs. You learn its grid, its components and its utilities — and, just as importantly, when reaching for it costs you more than writing the CSS yourself.

   • Bootstrap
   • Components
   • Grid
   • Utilities

   • Installing Bootstrap and how it is structured
   • The grid: containers, rows and breakpoints
   • Utility classes: spacing, colour, display
   • Components: navbars, cards, modals, forms
   • Customising with SASS variables instead of overrides
   • RTL support and Arabic layouts
   • and 1 more

   Open course
6. 06 The Craft SASS and SCSS Beginner 6 lessons 5 hours

   CSS with the tools a large stylesheet needs: variables, nesting, mixins and partials. The real subject here is architecture — how to organise styles so that a change in one place does not break something three files away.

   • SASS
   • SCSS
   • Mixins
   • Architecture

   • Why a preprocessor, and how compilation works
   • Variables, nesting and the nesting trap
   • Mixins, functions and @extend
   • Partials, imports and file architecture
   • Loops and maps for generating utilities
   • Project: a small design system in SCSS

   Open course
7. 07 The Modern Way Tailwind CSS Beginner 7 lessons 6 hours

   The utility-first approach that most new React projects start from. You learn the mental model, configure a theme that matches a brand, handle dark mode and RTL, and extract components before the markup turns into noise.

   • Tailwind
   • Utility-first
   • Config
   • Dark mode

   • Utility-first: the mental model
   • Installing Tailwind and the build step
   • Layout, spacing and responsive prefixes
   • Configuring the theme: colours, fonts, spacing
   • Dark mode and RTL support
   • Extracting components before the markup gets noisy
   • and 1 more

   Open course
8. 08 The Handoff Figma for Developers Beginner 6 lessons 5 hours

   Not a design course — a handoff course. You learn to read a Figma file the way a developer needs to: pulling exact spacing, colours and type scales, exporting assets at the right sizes, and asking the designer the right question instead of guessing.

   • Figma
   • Design handoff
   • Prototyping
   • Assets

   • The Figma interface for developers
   • Frames, auto layout and constraints
   • Inspect: reading exact values instead of guessing
   • Colour styles, text styles and design tokens
   • Exporting assets at the right sizes
   • Building a simple UI when there is no designer

   Open course
9. 09 The Team Git and GitHub Beginner 9 lessons 7 hours

   How professional teams actually work. Branches, pull requests, code review, and the one skill that separates confidence from panic: resolving a merge conflict without losing anyone else work.

   • Git
   • GitHub
   • Branching
   • Pull Requests
   • CI

   • How Git thinks: snapshots, not differences
   • Staging, committing and writing a useful message
   • Branching and merging
   • Remotes, push, pull and fetch
   • Resolving merge conflicts
   • Pull requests and code review
   • and 3 more

   Open course
10. 10 The Business Freelancing and Career Development Beginner 7 lessons 6 hours

    The half of the job nobody teaches. How to price work without underselling yourself, how to write a scope that protects both sides, how to build a portfolio that answers an employer question, and how to handle a technical interview when you do not kn

    • Freelancing
    • Portfolio
    • CV
    • Interviews
    • Pricing

    • A portfolio that answers what an employer is asking
    • Writing a CV for a specific role
    • Pricing: hourly, fixed and what each one costs you
    • Scope, contracts and preventing disputes
    • Finding your first clients
    • Client communication and handling change requests
    • and 1 more

    Open course
11. 11 The Framework React Fundamentals Intermediate 11 lessons 14 hours

    Component thinking, and the state decisions that quietly determine whether an application is still pleasant to work on six months later. You build real screens with routing, forms and data fetching, and treat loading and error states as first-class c

    • React
    • JSX
    • Hooks
    • Router
    • Forms

    • Why React exists and what problem it solves
    • JSX, components and props
    • State with useState, and where state should live
    • Rendering lists, keys and conditional UI
    • useEffect, dependencies and the infinite loop trap
    • useContext and sharing state without a library
    • and 5 more

    Open course
12. 12 Beyond the Basics Advanced React Advanced 9 lessons 12 hours

    What to do once the application is big enough to be slow or confusing. Custom hooks, composition patterns, memoisation applied where it is measured rather than sprinkled, code splitting, error boundaries, and a component library you can reuse across

    • React
    • Performance
    • Custom Hooks
    • Patterns
    • Suspense

    • Custom hooks: extracting logic properly
    • useReducer and state machines for complex state
    • useMemo, useCallback and memo, measured first
    • Profiling a React app and finding the real cost
    • Composition patterns and compound components
    • Code splitting, lazy and Suspense
    • and 3 more

    Open course
13. 13 Shared State Redux Toolkit Intermediate 7 lessons 8 hours

    A store, introduced at the point where passing props through five components actually starts to hurt — and not before. You learn slices, async thunks and RTK Query, plus the judgement to know when React own state was enough all along.

    • Redux Toolkit
    • RTK Query
    • State
    • DevTools

    • What a store is for, and when you do not need one
    • Store, slices, reducers and actions
    • Reading and updating state from components
    • Async thunks and loading states
    • RTK Query: caching and revalidation for free
    • Redux DevTools and time-travel debugging
    • and 1 more

    Open course
14. 14 The Mobile Side React Native Intermediate 8 lessons 10 hours

    The same component model, pointed at a phone. You build a real mobile app with navigation, device storage, permissions and a native feel, and learn where the web habits stop transferring.

    • React Native
    • Expo
    • Navigation
    • Mobile

    • React Native and Expo: how it differs from the web
    • Core components, styling and layout on mobile
    • Navigation: stacks, tabs and params
    • Lists, performance and long scrolls
    • Device storage and calling an API from mobile
    • Permissions, camera and location
    • and 2 more

    Open course
15. 15 The Server Node.js Intermediate 8 lessons 10 hours

    JavaScript outside the browser. You learn the runtime honestly — the event loop on the server, the file system, streams, and how a single-threaded process manages thousands of connections — before any framework hides it from you.

    • Node.js
    • Streams
    • Modules
    • NPM

    • The Node runtime and how it differs from the browser
    • The event loop on the server
    • Modules, NPM and managing dependencies
    • The file system, paths and environment variables
    • Streams and buffers for large data
    • Events, EventEmitter and async patterns
    • and 2 more

    Open course
16. 16 The API Express.js and REST APIs Intermediate 10 lessons 12 hours

    A structured Express application rather than one enormous file. Routes, controllers, services and middleware, an error contract the front end can rely on, and REST endpoints that another developer can use without asking you how they work.

    • Express
    • REST
    • Middleware
    • Validation

    • Express basics: routing and the request lifecycle
    • Middleware, order and why it matters
    • Project structure: routes, controllers, services
    • Designing REST resources and status codes
    • Request validation with schemas
    • An error contract the front end can rely on
    • and 4 more

    Open course
17. 17 The Data MongoDB and Mongoose Intermediate 9 lessons 12 hours

    Document databases on their own terms, not as a relational database with the joins removed. You learn when embedding beats referencing, how the aggregation pipeline answers the questions a report asks, and what an index does to a collection that has

    • MongoDB
    • Mongoose
    • Aggregation
    • Indexes
    • Modelling

    • Documents and collections: how they differ from tables
    • CRUD operations and query operators
    • Schema design: embed or reference
    • Mongoose models, validation and hooks
    • Relationships and populate
    • The aggregation pipeline
    • and 3 more

    Open course
18. 18 The Gate Authentication and Security Advanced 9 lessons 10 hours

    Who can do what, done properly. Password hashing, tokens that refresh and revoke, role-based access, and a pass over the vulnerabilities that show up in every security audit — taught as a checklist you can apply to your own project the same day.

    • JWT
    • OAuth
    • Bcrypt
    • OWASP
    • Roles

    • Password hashing with bcrypt, and why not encryption
    • Registration, login and password reset flows
    • JWT: signing, verifying and the refresh problem
    • Sessions versus tokens, and choosing between them
    • Roles, permissions and protecting routes
    • OAuth and social login
    • and 3 more

    Open course
19. 19 The Media File Upload and Cloud Storage Intermediate 6 lessons 6 hours

    Handling files without opening a hole or filling a disk. Validating what was actually uploaded rather than what it claims to be, processing images, moving storage off the application server, and serving media so it does not slow every page down.

    • Uploads
    • Multer
    • Cloudinary
    • S3
    • Images

    • Handling multipart uploads with Multer
    • Validating type and size on the server, not the client
    • Image processing, resizing and formats
    • Cloud storage: Cloudinary and S3-compatible services
    • Signed URLs and protecting private files
    • Serving media without slowing the page down

    Open course
20. 20 Going Live Deployment and DevOps Advanced 7 lessons 8 hours

    Getting the application off your machine and keeping it up. Environment configuration, a pipeline that runs the tests before anything ships, logging you can search at two in the morning, and monitoring that tells you something broke before a customer

    • Deployment
    • CI/CD
    • Environments
    • Monitoring

    • Environment configuration and keeping secrets safe
    • Deploying a React front end
    • Deploying a Node API and connecting a database
    • Domains, HTTPS and certificates
    • A CI/CD pipeline with tests as a gate
    • Structured logging and correlation ids
    • and 1 more

    Open course
21. 21 The Safety Net Testing Advanced 7 lessons 8 hours

    Tests as the thing that lets you change code without fear. You learn what is worth testing and what is noise, test an API end to end, test React components the way a user meets them, and run the whole suite automatically on every push.

    • Jest
    • Supertest
    • React Testing Library
    • E2E

    • Why test, and what is actually worth testing
    • Unit tests with Jest
    • Testing an Express API with Supertest
    • Test databases, fixtures and isolation
    • Testing React components by behaviour
    • End-to-end tests for the critical flow
    • and 1 more

    Open course
22. 22 The Types TypeScript Advanced 7 lessons 9 hours

    Types used to make wrong states impossible rather than to add ceremony. You type a React application and an Express API, learn generics without the fear, and see the class of bug that simply stops happening.

    • TypeScript
    • Types
    • Generics
    • React

    • TypeScript for people who already write JavaScript
    • Primitives, objects, arrays and interfaces
    • Unions, narrowing and type guards
    • Generics without the fear
    • Typing a React application
    • Typing an Express API and sharing types
    • and 1 more

    Open course
23. 23 The Full-Stack Framework Next.js Advanced 8 lessons 10 hours

    React with a server attached. Rendering strategies and what each one costs, file-based routing, API routes, and the SEO and performance wins that a plain single-page application cannot get.

    • Next.js
    • SSR
    • SSG
    • Routing
    • SEO

    • What Next.js adds to React, and what it costs
    • File-based routing and layouts
    • Rendering strategies: static, server, client
    • Data fetching and caching on the server
    • API routes and server actions
    • Images, fonts and built-in optimisation
    • and 2 more

    Open course
24. 24 The Alternative GraphQL Advanced 6 lessons 8 hours

    A different contract between client and server: the client asks for exactly the fields it needs. You build a schema and resolvers, consume it from React, and learn the two problems GraphQL creates in exchange for the ones it solves.

    • GraphQL
    • Apollo
    • Schema
    • Resolvers

    • GraphQL versus REST: what actually changes
    • Schema, types, queries and mutations
    • Resolvers over a real database
    • Apollo Client in React
    • Caching, optimistic updates and refetching
    • The N+1 problem, batching and depth limits

    Open course
25. 25 Real Time Socket.IO and Real Time Advanced 7 lessons 7 hours

    When request and response is not enough. Live chat, notifications and presence, built with rooms and namespaces — and an honest look at what keeping thousands of open connections costs you.

    • Socket.IO
    • WebSockets
    • Rooms
    • Realtime

    • WebSockets and what Socket.IO adds
    • Events, emitting and listening on both sides
    • Rooms, namespaces and targeting the right users
    • Authenticating a socket connection
    • Presence, typing indicators and delivery state
    • Scaling sockets and what it costs
    • and 1 more

    Open course
26. 26 The Infrastructure Docker and VPS Deployment Advanced 8 lessons 9 hours

    Owning the server instead of renting a button. You containerise the whole stack, compose it, and deploy it to a Linux VPS you configured yourself — firewall, reverse proxy, certificates, process manager and backups included.

    • Docker
    • Nginx
    • VPS
    • Compose
    • Linux

    • Why containers: the same environment everywhere
    • Writing a Dockerfile for a Node API
    • Containerising a React build behind Nginx
    • Docker Compose: the stack in one file
    • Linux basics on a VPS: users, permissions, firewall
    • Nginx as a reverse proxy, domains and HTTPS
    • and 2 more

    Open course
27. 27 The Speed Performance Optimisation Advanced 6 lessons 7 hours

    Measure, then fix — in that order. Core Web Vitals on the front end, query plans and caching on the back end, and the discipline of proving a change helped rather than assuming it did.

    • Performance
    • Caching
    • Redis
    • Web Vitals

    • Core Web Vitals and measuring them honestly
    • Bundle analysis, splitting and lazy loading
    • Images, fonts and third-party script cost
    • Finding the slow query behind a slow page
    • Caching strategies and the invalidation problem
    • Redis for caches, counters and rate limits

    Open course
28. 28 The Money Payments with Stripe Advanced 6 lessons 6 hours

    Taking money correctly, which is mostly about what happens when something goes wrong. Checkout, subscriptions, and webhook handling that does not charge anyone twice when the same event arrives twice.

    • Stripe
    • Payments
    • Webhooks
    • Idempotency

    • How a payment actually flows, end to end
    • Stripe Checkout without touching card data
    • Webhooks, signature verification and retries
    • Idempotency: surviving the same event twice
    • Subscriptions, invoices and failed payments
    • Refunds, disputes and the records you must keep

    Open course
29. 29 The Edge AI Integration Advanced 6 lessons 7 hours

    Adding AI features to a product you already built, treated as engineering rather than magic. Calling a model API, streaming a response into the interface, grounding answers in your own data, and controlling cost and failure.

    • AI
    • LLM APIs
    • Embeddings
    • RAG
    • Streaming

    • Calling a model API from the server, never the client
    • Prompts, context and getting a usable answer
    • Streaming a response into a React interface
    • Embeddings and searching your own content
    • Retrieval-augmented answers grounded in your data
    • Cost, rate limits and failing safely

    Open course
30. 30 The Capstone Graduation Project Advanced 8 lessons 24 hours

    One application, yours, taken the whole way: from a brief and a data model through to a deployed product with an admin dashboard, documentation and a presentation. This is the piece you will actually be interviewed about.

    • Capstone
    • Full Stack
    • Deployment
    • Documentation

    • Choosing a project that is worth your nine months
    • Scoping the brief and the data model
    • Building the API and the database
    • Building the interface and connecting it
    • Authentication, roles and the admin dashboard
    • Testing, hardening and deploying to production
    • and 2 more

    Open course
31. 31 The Portfolio Workshop Projects Advanced 7 lessons 20 hours

    Guided build sessions that turn everything you have learned into a portfolio someone will read. Each workshop is a complete small product, built live with review, so you also learn how other people read your code.

    • Workshops
    • Portfolio
    • Code Review
    • Practice

    • Workshop: a task management system with teams
    • Workshop: a blog platform with an editor and roles
    • Workshop: an e-commerce platform with payments
    • Workshop: an admin dashboard with reporting
    • Code review: reading and being read
    • Refactoring your first projects with what you know now
    • and 1 more

    Open course

• Front-End Developer
• React Developer
• JavaScript Developer
• Back-End Developer
• Node.js Developer
• MERN Stack Developer
• Full-Stack Developer
• Web Application Developer
• Software Engineer
• Freelance Web Developer