Courses

Showing 0 of 0 labs

New Challenge

1h 30m

Web Fundamentals · 🎓 Capstone — Build StreamVerse

Web Development · Intermediate

✓ The graduation of the Web Development path: no step-by-step code — you assemble everything you've learned about layout and responsive design into one complete, portfolio-grade site
✓ Starting from a scaffold (a full StreamVerse landing page whose HTML is all there but whose CSS has no layout, so every section stacks), you build a horizontal navbar, a two-column hero, a 3-up card grid, and a multi-column footer — then make the whole page reflow to a single column on a phone
✓ Every requirement is graded by a real headless browser that loads your page, measures the actual rendered geometry at real viewports, and passes only when your layout genuinely renders correctly — including a true desktop→mobile reflow no DOM-string checker can fake

HTML Semantics & Forms: Structure, Data & Input

Web Development · Beginner

✓ Go beyond the basics and build the pages employers actually pay for — a semantic page layout (header/nav/main/section/article/aside/footer), data tables that screen readers can navigate, and real, accessible forms (inputs, selects, textareas, labels, and built-in validation)
✓ Finish by shipping a complete, accessible contact page
✓ Every lesson is browser-run and graded on hidden tests against your live DOM, with a dedicated focus on accessibility and ARIA

HTML Foundations: Structure the Web

Web Development · Beginner

✓ Learn to build web pages with HTML — the skeleton of every website
✓ Write a valid HTML5 document, add head metadata for the browser and search engines, mark up headings and text with meaning, build ordered/nested lists, add links and accessible images, and lay out a page with semantic tags (header/nav/main/section/article/footer)
✓ Browser-run, graded on hidden tests against your live DOM

CSS Responsive & Motion: Adapt and Delight

Web Development · Beginner

✓ Make your pages work on every screen and feel alive
✓ Write mobile-first media queries, build layouts that reflow with fluid units and responsive grids, tame repetition with CSS custom properties, add interactive polish with pseudo-classes and pseudo-elements, paint with gradients, shadows and rounded corners, and bring motion with transitions and keyframe animations — finishing with a responsive, animated hero section
✓ Browser-run, graded on hidden tests against your declared CSS

CSS Layout: Flexbox & Grid

Web Development · Beginner

✓ Master modern CSS layout — the two systems every real interface is built on
✓ Control the normal document flow (block, inline, inline-block, none), build one-dimensional layouts with Flexbox (direction, alignment, wrapping and flexible items), and two-dimensional layouts with CSS Grid (template columns, gaps, line placement, spanning and named areas)
✓ Finish by combining Flexbox and Grid into a real header/sidebar/main page and a responsive-ready card grid

CSS Foundations: Style the Web

Web Development · Beginner

✓ Take your HTML pages from plain to polished with CSS — the language that styles every website
✓ Learn to apply CSS and target elements with type, class and id selectors; master the cascade, specificity and inheritance; size and space boxes with the box model and box-sizing; set colors and backgrounds with hex and rgb; use px, em, rem, percentage and viewport units; and craft readable typography
✓ You finish by styling a real profile card to spec

JavaScript Foundations: Variables, Types & Operators

JavaScript · Beginner

✓ Start your JavaScript journey in the browser
✓ Declare variables with let/const, reason about the primitive types and typeof, use arithmetic/comparison/logical operators, predict truthy/falsy coercion, branch with if/else, and loop with for/while
✓ Browser-run, graded on hidden tests

JavaScript · 0 — The DOM by Hand

JavaScript · Beginner

✓ You know JavaScript syntax — now make a real web page come alive with the raw DOM API, no framework
✓ By the end you can select and read elements, change the page, build a list from data, respond to clicks and typing, and use event delegation — and you'll feel EXACTLY why React exists before you write a line of it
✓ This is the prerequisite for the React path

JavaScript Functions: Scope & Closures

JavaScript · Beginner

✓ Define functions three ways (declaration, expression, arrow), use default and rest params, reason about block scope and hoisting, and build closures and higher-order functions — a reusable toolbox of utilities
✓ Browser-run, graded on hidden tests

JavaScript Objects & Arrays

JavaScript · Beginner

✓ Model data with objects, master array method pipelines (map/filter/reduce), and use destructuring + spread/rest — through a shopping-cart / student-records spine
✓ Browser-run, graded on hidden tests

JavaScript Async

JavaScript · Beginner

✓ Callbacks, Promises, async/await, Promise
✓ all and async error handling — reason about the event loop and orchestrate asynchronous work over a mock streaming API
✓ Browser-run, graded on hidden tests

JavaScript Modern: ES6+ Features

JavaScript · Beginner

✓ Model with ES6 classes and inheritance, format with template literals, use Map/Set, produce sequences with generators, and write safe access with optional chaining and nullish coalescing — through a small media-library spine
✓ Browser-run, graded on hidden tests

MERN Project · 1 — Build the Screens (React)

React · Intermediate

✓ Your CineList journey starts with what users actually see
✓ In this module you turn a flat list of movies into a real React interface: you carve out your first reusable component, feed it data through props, render a whole list, make it react to clicks, remember things with state, and finish with a search box that filters movies live as you type
✓ You preview every change in a real browser tab, so the UI you build is the UI you see

React · 1 — Foundations

React · Beginner

✓ You've never run React — now build and compose your first components with JSX in a real Vite app
✓ By the end you can create components, embed JavaScript in JSX, compose a page from Header/Hero/Footer, render a badge conditionally, split components into their own files, and build a nav from scratch
✓ No prior React needed

MERN Project · 2 — Multi-Page App (React Router)

React · Intermediate

✓ Your CineList screen works — now turn it into a real app with more than one page
✓ In this module you add routing so the URL controls what's shown, build a navbar and pages that switch without reloading, give every movie its own detail page, and add a form so users can put in new movies — with validation so bad data never gets through
✓ You preview every change live in a browser tab

React · 2 — Components & Props

React · Beginner

✓ You can render JSX — now build REUSABLE, DATA-DRIVEN components
✓ By the end you can pass data into a component with props, give props sensible defaults, forward content with the children prop, render a list with
✓ map and keys, show a graceful empty state, compose a reused sub-component, and render an array as a row of chips

React · 3 — State & Events

React · Beginner

✓ You can build reusable, data-driven components — now make them RESPOND to the user
✓ This is the re-render 'aha' course: you handle click events, give a component MEMORY with useState, drive the UI from state, update arrays immutably, derive a live search filter, lift state up to a shared parent, and remove items from a list
✓ You turn StreamVerse's static grid into an interactive app — favourite toggles, a watch counter, a watchlist, and search-as-you-type

MERN Project · 4 — Connect Front & Back (fetch)

React · Intermediate

✓ You built screens
✓ You built an API
✓ They've never met

React · 4 — Hooks

React · Beginner

✓ You can build interactive, state-driven components — now reach beyond React into the outside world with hooks
✓ This is the escape-hatches course: you synchronize the browser tab title with state using useEffect, control WHEN effects run with a dependency array, start and CLEAN UP a live timer with setInterval/clearInterval, focus a DOM input with useRef, extract a reusable useLocalStorage hook so your watchlist survives a reload, learn when you DON'T need an effect (derive instead), and finish by writing your own useDebounce hook to power search-as-you-type
✓ Every step ends with you SEEING the effect in StreamVerse

React · 5 — Forms & Data

React · Beginner

✓ You can build interactive, hooks-wired components — now capture what the user types and load real data over the network
✓ This is the forms-and-fetching course: you build a controlled input where React state is the single source of truth, assemble a full add-movie form with onSubmit and e
✓ preventDefault(), add validation that blocks a bad submit and shows an inline error, replace your local array with a real fetch('/api/movies') inside useEffect, handle the loading and error states every network request needs, wire search-as-you-type over the fetched data, and finish by building a validated rate-movie form on your own

React · 6 — Routing & App State

React · Beginner

✓ You can build interactive, hooks-wired components that fetch real data — now turn one screen into a real multi-page app
✓ This is the routing-and-shared-state course: you add React Router with BrowserRouter and Routes so different URLs render different pages, build a Navbar with <Link>s that switch pages without a reload, add a dynamic /movies/:id route whose MovieDetail reads the id with useParams, navigate programmatically with useNavigate (a search box that jumps to a results page), lift your watchlist into app-wide state with Context so any page can add to it with no prop drilling, handle unknown URLs with a friendly 404 behind a shared <Outlet/> layout, and finish by building a complete My Watchlist page that reads Context and removes items
✓ Every step ends with you SEEING StreamVerse become a real, navigable app

React · 🎓 Capstone — Build StreamVerse

React · Beginner

✓ The graduation of the React path: no step-by-step code — you assemble everything you've learned into one complete, working StreamVerse app
✓ Starting from a scaffold (the Course-6 app with its key pieces stubbed out as TODOs), you build a fetched Home grid with loading and error states, a dynamic /movies/:id detail page that opens when you click a card, a Context-backed watchlist you can add to from anywhere and remove from a My Watchlist page, and a validated search form that jumps to a results page — then prove the whole user journey works end-to-end: browse, search, open a detail, add to your watchlist, and see it there
✓ Every requirement is graded by a hidden component test that renders your real app and drives real interactions, so it passes only when your app genuinely works

Node.js · 1 — The Runtime: JavaScript Unleashed

Node.js · Beginner

✓ Run JavaScript outside the browser and build real command-line tools in your first hour
✓ Starting from a bare workspace, you'll write Node programs that read files, split code into modules, install a real npm package offline, and take configuration from the outside world
✓ You'll also PROVE how Node actually works — watch the event loop's exact scheduling order and clock two async tasks running in parallel — by experiment, not lecture

Node.js · 2 — Express: HTTP Done Right

Node.js · Beginner

✓ Bring a real HTTP service online
✓ You'll feel the pain of a raw Node `http` server (headers and 404s are all YOUR job), then earn Express: routes with URL params and query filters, honest 404s, middleware that provably runs on every request, static file serving, and a centralized error handler so a crash never leaks a stack trace to a client
✓ Every check curls your actual running server and inspects real HTTP behavior — status codes, headers, JSON — never your source text

Node.js · 3 — REST APIs That Behave

Node.js · Beginner

✓ Design a REST resource the way production expects it
✓ On top of your Express server from Node
✓ js · 2, you'll build StreamVerse's Watchlists API end to end: POST that answers 201 with a Location header, collection reads with X-Total-Count, PUT-vs-PATCH semantics, idempotent DELETE (204 then 404), boundary validation that returns 422 without corrupting the store, capped pagination you seed through your own API, and a nested items sub-resource with honest 422/409/404

MERN Project · 3 — Build the API (Node + Express)

Node.js · Intermediate

✓ Your screens are built — now build the engine behind them
✓ In this module you stand up a real Node
✓ js + Express server, hand data back over the web as JSON, accept new data, watch every request flow through middleware, and fail gracefully

Node.js · 4 — Files & Streams at Scale

Node.js · Intermediate

✓ Give your service a real data plane
✓ Starting from the StreamVerse REST API you built in Course 3, you'll make it survive restarts with durable file persistence, then process a 66 MB / 600,000-line event log without blowing up memory — proven by MEASURING RSS, counting real backpressure pauses, gzipping with pipeline, and streaming huge files over HTTP in both directions
✓ Every result is observed, not asserted

Node.js · 5 — The Database Layer

Node.js · Intermediate

✓ Wire a real database into a running Node service
✓ Starting from a working Express app that persists to JSON files, you'll connect ONE pooled MongoClient, then build CRUD endpoints graded against live MongoDB state: query with filters, projection and capped pagination; enforce ObjectId discipline (400 for malformed, 404 for unknown); run atomic update operators over HTTP; map a unique-index violation to a clean 409; and finish by streaming 600,000 events into the database with a batched bulk importer
✓ Every check curls your live server and cross-checks the truth in mongod

Node.js · 6 — Auth & API Defense

Node.js · Intermediate

✓ Turn an open API into a defended one
✓ You'll hash passwords with bcrypt (and prove the plaintext never reaches the database), issue and verify JWTs with role claims, write an auth middleware that gives honest 401-vs-403 answers, strip framework fingerprints with helmet, and add rate limits that produce real 429s under a brute-force hammer
✓ Every rule is proven the way attackers and reviewers test it — a curl for the status code or header, plus a mongosh peek at what actually landed in the database

MERN Project · 6 — Login & Security (JWT)

Full-Stack · Advanced

✓ Your CineList app shows movies — now make it real
✓ In this module you connect your React screens to the live server, let people sign up safely (passwords are hashed, never stored raw), hand out a login pass (a token), lock the doors so only signed-in users can add movies, and keep people logged in across page reloads
✓ By the end you have a genuine, secure full-stack app

Node.js · 7 — 🎓 Capstone: Production-Ready

Node.js · Intermediate

✓ Turn a feature-complete Node
✓ js service into a DEPLOYABLE one — and prove it
✓ Starting from your auth-secured, database-backed StreamVerse Platform, you'll add the six things every production backend needs: fail-fast config (the process refuses to boot without its secrets), structured JSON logs with a request ID on every response, a uniform error envelope that never leaks a stack trace, liveness vs readiness health checks, graceful shutdown that drains an in-flight request on SIGTERM before exiting cleanly, and crash guards that die loudly instead of limping on

MERN Project · 7 — Image Uploads (Multer)

Full-Stack · Advanced

✓ Your CineList app reads, writes, and logs people in — but every movie still shows up without a picture
✓ In this final module you let users upload movie posters: accept a real image file with multer, store it on the server, serve it back over a URL, and finally render those posters in your React UI
✓ By the end CineList looks like a finished product — movies with posters, uploaded by your users

Java · 1 — Code on the JVM

Java · Beginner

✓ Write, compile and run your first real Java programs in 60 seconds — on a real Temurin JDK 25, no install
✓ Build StreamVerse's pricing brain as small command-line programs: typed variables, operators and formatted money (GST included), decisions with switch on program arguments, loops with break/continue, and methods with parameters and returns
✓ No prior programming needed

Java · 2 — Object-Oriented Thinking

Java · Beginner

✓ Turn procedural scripts into a real domain model
✓ On a live Temurin JDK 25 — no install — you rebuild StreamVerse as objects: classes with encapsulated state, constructors and toString, inheritance with super, polymorphism proven by dynamic dispatch, interfaces as contracts, and custom exceptions
✓ Every step is checked by RUNNING your classes through a test driver — real behavior, never keyword matching

Java · 3 — Collections & Streams

Java · Intermediate

✓ Turn a raw 50-row CSV catalog into a working in-memory engine — on a real Temurin JDK 25, no install
✓ Master the collections a backend job actually needs: ArrayList, HashMap and HashSet; write your own generic Repository<T>; and run measurable stream pipelines (filter, map, groupingBy, Optional) that compute real analytics
✓ Every step compiles, runs and is checked against values only correct logic produces

Spring Boot · 4 — Your First Service

Java · Intermediate

✓ Stand up your first real backend
✓ On a live Temurin JDK 25 + Spring Boot 4
✓ 1 server — no install — you build StreamVerse's API: package and run a jar the production way (java -jar + a pidfile), serve JSON from an @RestController, PROVE dependency injection by swapping an implementation and watching the response change, bind typed configuration, and flip behaviour with dev/prod profiles

Spring Boot · 5 — REST APIs Done Right

Java · Intermediate

✓ Design a real REST API the way senior engineers do
✓ On a live Temurin JDK 25 + Spring Boot 4
✓ 1 server — no install — you turn StreamVerse's catalog into a full CRUD API: GET/POST/PUT/DELETE with the CORRECT status codes (200/201/204/404), a Location header on create, bean validation that rejects bad input at the door with a 400 naming the field, a consistent ProblemDetail error contract, and query filtering

Spring Boot · 6 — Data & Security

Java · Advanced

✓ Turn a toy API into a real service
✓ On a live Temurin JDK 25 + Spring Boot 4
✓ 1 server — no install — you give StreamVerse's API a memory and a lock: persist movies and reviews with Spring Data JPA on an H2 file database (and PROVE it by watching a row survive a full restart), write derived queries and a @ManyToOne relationship, then bolt on Spring Security — feel the 401 shock when you add the starter, restore public reads, add BCrypt-hashed users, and enforce ADMIN-only deletes with real 401-vs-403 behaviour

Spring Boot · 7 — 🎓 Ship StreamVerse

Java · Advanced

✓ Turn a working Spring Boot service into a DEPLOYABLE 1
✓ 0 release — and prove it
✓ Starting from your JPA-backed, security-locked StreamVerse API, you add the things every production backend needs: actuator health details and build/app info, self-describing OpenAPI docs at /v3/api-docs, a hardened prod profile that leaks nothing, graceful shutdown that drains an in-flight request on SIGTERM before exiting cleanly, file logging you can grep, and an executable smoke suite — then you tag 1

Python Programming Mastery Quiz

Python Programming · Beginner

✓ Hands-on end-of-path assessment for Python (R23)
✓ Five cumulative coding challenges spanning control flow, strings, lists, dicts and data — graded on hidden tests
✓ This is the CO-attainment instrument (measures K3/K4 by making students build, not pick options)

Python Functions & OOP

Python Programming · Beginner

✓ R23 Unit II (functions) & Unit IV (files, OOP) — reusable functions, file processing, and classes, through job-relatable tasks
✓ Browser-run, graded on hidden tests

Python Foundations

Python Programming · Beginner

✓ R23 Unit I — Python basics, control flow and operators, taught through job-relatable tasks
✓ Runs in the browser (no pod) and is graded against hidden test cases

Python Data Structures

Python Programming · Beginner

✓ R23 Units II–III & V — strings, lists, dictionaries, tuples, sets, and first steps in NumPy/Pandas, through job-relatable tasks
✓ Browser-run, graded on hidden tests

C: Programming Mastery Quiz

C Programming · Beginner

✓ R23 Computer Programming Lab (B23CS1102) — a mixed mastery challenge across the C lab: FizzBuzz, array max & sum, palindrome check, swap-via-pointers, and recursive GCD
✓ Browser-run in C, graded on hidden tests

C Pointers, Memory & Structures

C Programming · Beginner

✓ R23 Computer Programming Lab (B23CS1102) — pointers, call-by-reference, dynamic memory (malloc/calloc/realloc), structures and linked lists, framed around how real software manages memory and data
✓ Browser-run, graded on hidden tests

C Functions & Recursion

C Programming · Beginner

✓ R23 Computer Programming Lab (B23CS1102) — modular programming with functions and recursion (nCr, GCD, power, factorial, Fibonacci) framed as reusable building blocks
✓ Browser-run, graded on hidden tests

C Programming Foundations

C Programming · Beginner

✓ R23 Computer Programming Lab (B23CS1102) — C from your first compile to loops, taught through real-world tasks (fintech math, feature flags, tiered billing)
✓ Browser-run, graded on hidden tests

C File Handling

C Programming · Beginner

✓ R23 Computer Programming Lab (B23CS1102) — reading/writing files and streams: wc-style counting, transforms, tail, real fopen read/write, line reversal and numbering, framed as the log/CSV tools engineers actually build
✓ Browser-run, graded on hidden tests

C Arrays & Strings

C Programming · Beginner

✓ R23 Computer Programming Lab (B23CS1102) — 1-D & 2-D arrays, searching, sorting, matrices and C strings, through real-world tasks (leaderboards, matrix transforms, text processing)
✓ Browser-run, graded on hidden tests

MySQL · 1 — Relational Foundations & Schema Design

Databases · Beginner

✓ Design your first real database in 60 seconds
✓ Build the StreamVerse schema from a blank MySQL server: create the database, define tables with deliberately-chosen data types, and add PRIMARY KEY, NOT NULL, UNIQUE, CHECK and FOREIGN KEY constraints — then watch the database itself reject bad data
✓ Finish by evolving the live schema with ALTER TABLE

MongoDB · 1 — Document Database Foundations

Databases · Beginner

✓ Store your first real data in MongoDB in 60 seconds
✓ Build the StreamVerse movie catalog from an empty database: insert documents with nested objects and arrays, bulk-load with insertMany, read them back with find + projection, rank with sort/limit, and understand _id identity
✓ No SQL background needed

PostgreSQL · 1 — Relational Foundations & Schema Design

Databases · Beginner

✓ Design your first real database in PostgreSQL — the world's most loved relational database
✓ Build the StreamVerse schema from a blank cluster: create databases and tables with deliberately chosen types (IDENTITY, TEXT, NUMERIC, TIMESTAMPTZ), then make the database itself enforce your business rules with PRIMARY KEY, NOT NULL, UNIQUE, CHECK and FOREIGN KEY — and watch it reject bad data with real error codes
✓ No prior database experience needed

MySQL · 2 — CRUD & Everyday Queries

Databases · Beginner

✓ Run a real production ops desk
✓ The StreamVerse catalog just shipped — now onboard subscribers with multi-row INSERT, answer precise questions with SELECT / WHERE / ORDER BY / LIMIT, filter with LIKE / IN / BETWEEN, mutate live data safely with UPDATE and DELETE (and learn why production soft-deletes), and roll it all up with GROUP BY / HAVING
✓ Every skill graded against real rows and real report files

MongoDB · 2 — CRUD Operations

Databases · Beginner

✓ Your StreamVerse catalog is live — now bring in the customers
✓ Onboard 10 subscribers with embedded subscription plans and watchlists, filter them with query operators ($gte, $in, $ne, $exists), update documents in place with $set, mutate counters and arrays atomically with $inc and $addToSet, query inside nested objects with dot-notation, and clean up safely with deleteMany + upsert
✓ This is the CRUD toolkit behind every production API

PostgreSQL · 2 — CRUD & Everyday Queries

Databases · Beginner

✓ The catalog shipped — now run StreamVerse's ops desk
✓ Master the four verbs of every backend job the PostgreSQL way: multi-row INSERT, precise SELECT with WHERE / ORDER BY / LIMIT, pattern-set-and-range filters (ILIKE, IN, BETWEEN), and UPDATE / DELETE with RETURNING — Postgres's superpower that shows you exactly what you changed, in the same statement
✓ Finish with GROUP BY / HAVING analytics and a no-code challenge that launches a whole subscription drive in three statements

MySQL · 3 — Joins & Relationships

Databases · Beginner

✓ 300 raw reviews just hit your database — nothing but ids and numbers
✓ Turn them into answers: join reviews to movies, hunt down the titles nobody reviews, chain three tables into one report, walk a referral tree with a self-join, and feel foreign keys guard (then cascade) a real account deletion
✓ Finish by wiring a many-to-many genre catalog and shipping a 4-table analytics dashboard

PostgreSQL · 3 — Joins & Relationships

Databases · Beginner

✓ Answer real questions that span tables — the skill that turns SQL from a toy into a career
✓ Join StreamVerse's brand-new 300-review import to the catalog with INNER JOIN, hunt the never-reviewed movies with LEFT JOIN + IS NULL, reconcile a partner's title feed with a FULL OUTER JOIN (something MySQL literally cannot do), chain three tables, walk the referral graph with a self-join, wield ON DELETE CASCADE deliberately, and finish by designing a many-to-many junction table with a composite primary key
✓ Everything runs free in your browser — no install, no cloud account

MongoDB · 3 — The Aggregation Pipeline

Databases · Intermediate

✓ Turn 200 raw reviews into executive analytics — one pipeline stage at a time
✓ Build real aggregation pipelines over the StreamVerse catalog: filter and reshape with $match/$project, compute stats with $group, rank with $sort/$limit, explode arrays with $unwind, join collections with $lookup, and materialize every result with $out
✓ This is the exact skill behind every dashboard, leaderboard, and report you've ever seen

PostgreSQL · 4 — Advanced SQL: CTEs, Windows, JSONB & Full-Text

Databases · Intermediate

✓ Use the features people choose PostgreSQL for
✓ Build StreamVerse's analytics layer with subqueries, readable CTEs, a genuinely recursive query that walks the referral tree, and window functions that rank and trend without collapsing rows
✓ Then go where most SQL courses never do: query and mutate JSONB documents inside a relational table (with a GIN index), and ship real full-text search — stemmed, indexed, and beyond anything LIKE can do

MySQL · 4 — Advanced Queries: CTEs, Window Functions & Views

Databases · Intermediate

✓ Think in layers, like an analyst
✓ Build StreamVerse's analytics layer on a real MySQL 8
✓ 0 server: label data with CASE, compare rows to computed values with subqueries, name your steps with CTEs, rank within groups and compute month-over-month trends with window functions (RANK, LAG, SUM OVER), and publish it all as views

MongoDB · 4 — Data Modeling & Schema Design

Databases · Intermediate

✓ Think like the engineer who designs the database, not just queries it
✓ On the StreamVerse catalog you've built since Course 1, make real schema decisions: embed a user profile for one-read pages, reference unbounded watch events, model actors↔movies many-to-many, denormalize rollups with the computed pattern, tame time-series with buckets, and enforce a write-time contract with $jsonSchema validation
✓ Everything runs free in your browser — no install, no cloud account

PostgreSQL · 5 — Indexes & Query Performance

Databases · Intermediate

✓ The day StreamVerse's 100,000-row plays export landed, every dashboard query slowed to a crawl — and fixing that is one of the most valuable skills in backend engineering
✓ Learn to read what PostgreSQL actually does with EXPLAIN (ANALYZE), then fix it with the right index for the job: B-tree, composite (and the leftmost-prefix rule), partial, covering with INCLUDE (the Index Only Scan), and GIN for JSONB
✓ You'll watch Seq Scans over 100k rows turn into index scans that touch a few hundred — proven by the query plans themselves, not a stopwatch

MySQL · 5 — Indexes & Query Performance

Databases · Intermediate

✓ Make a 100,000-row table fast — and prove it with query plans
✓ The plays export just landed and every query on it reads all 100k rows
✓ Learn to read EXPLAIN like a performance engineer, then fix real slow queries with single-column, composite and covering indexes; measure selectivity to know when an index can't help; run the slow-query-log diagnosis loop; and finish by designing the one index that serves the app's hottest query — filter, sort and select list, no filesort

MongoDB · 5 — Indexes & Performance

Databases · Intermediate

✓ Your queries work — now make them fast
✓ StreamVerse just handed you 50,000 raw watch events and every hot query is scanning all of them
✓ Diagnose the damage with explain("executionStats"), then fix it like a database engineer: single-field, compound (and the left-prefix rule), multikey, text, and unique indexes — plus covered queries and the ESR rule — turning COLLSCAN into IXSCAN and 50,000 docs examined into a handful

MySQL · 6 — Transactions, Locks & Concurrency

Databases · Intermediate

✓ Money must never appear or vanish
✓ StreamVerse launches wallet-to-wallet gifting, and you make it bulletproof: write real ACID transactions, watch ROLLBACK erase a mistake, observe REPEATABLE READ vs READ COMMITTED live, capture a genuine lock-wait timeout (error 1205), manufacture and diagnose a REAL deadlock (error 1213) with SHOW ENGINE INNODB STATUS, then prove your locking survives a 20-transfer parallel storm to the exact rupee
✓ The concurrency skills every backend interview probes — practiced on a real server, free in your browser

PostgreSQL · 6 — Transactions, MVCC & Concurrency

Databases · Intermediate

✓ The course almost nobody teaches hands-on: make money move correctly under concurrency
✓ StreamVerse launches wallet-to-wallet gifting and you write the transactions behind it — atomic transfers with BEGIN/COMMIT, undo with ROLLBACK, isolation levels you OBSERVE live from two racing sessions, row locks with real 55P03 lock-timeout errors, PostgreSQL's MVCC storage engine measured in dead tuples and reclaimed with your own VACUUM, and a genuine serialization failure (SQLSTATE 40001) you produce, capture and understand
✓ Finale: the overdraft-proof transfer in one atomic data-modifying CTE

MongoDB · 6 — Transactions, Security & Production Ops

Databases · Intermediate

✓ Money is on the line now
✓ StreamVerse subscribers hold real credit balances — and you'll move them the way production systems do: guarded atomic writes with majority writeConcern, multi-document ACID transactions that commit or vanish completely, a deliberate abort to prove rollback, read-only vs readWrite users the server actually enforces, mongodump/mongorestore when the 'oops' happens, and the profiler to catch slow queries live
✓ Runs on a real single-node replica set with auth ON — the production posture, free in your browser

MongoDB · 7 — 🎓 Capstone: Build the StreamVerse API

Databases · Intermediate

✓ The graduation project: wire everything you've learned into a REAL Node
✓ js REST API with the official MongoDB driver
✓ Boot an Express server on a pooled MongoClient, then ship the endpoints every backend job expects — paginated GET /movies, GET /movies/:id with proper 400/404s, POST with validation and 201s, full-text /search riding your text index, an aggregation-powered /stats/genres, and a /signup that turns a duplicate-key error into a clean HTTP 409

MySQL · 7 — Administration, Security & Backup

Databases · Intermediate

✓ Stop being a query-writer
✓ Run the server
✓ StreamVerse hires its first team and you're the DBA: create least-privilege accounts and watch the engine DENY the writes they shouldn't make, revoke access surgically and prove exactly what's left, take a real mysqldump of the whole production database, restore it into a fresh database with row-count proof, and turn on the server's operational eyes

PostgreSQL · 7 — Administration, Security & Backup

Databases · Intermediate

✓ Graduate from writing queries to RUNNING PostgreSQL
✓ StreamVerse just hired its first team and you're the DBA: create least-privilege roles and watch the server deny their forbidden writes with real error 42501, take a pg_dump backup and prove it by actually restoring it with matching row counts, then switch on pg_stat_statements and read the server's vital signs like a production engineer
✓ Everything runs free in your browser — no install, no cloud account

Git · 1 — Foundations

Git · Beginner

✓ Never lose your work again
✓ By the end you can configure git, turn any folder into a tracked repository, stage and commit changes, read your project's history, and keep junk out with
✓ gitignore — the version-control skills every engineering job assumes on day one

Git · 2 — Branching & Merging

Git · Beginner

✓ Stop working on one fragile timeline
✓ By the end you can create branches to develop features in isolation, merge them back with fast-forwards and real merge commits, resolve a merge conflict by hand, and prune merged branches — the everyday parallel-development workflow every team runs on
✓ Runs free in your browser, no account needed

Git · 3 — Remote Repositories

Git · Intermediate

✓ Your commits are safe on your laptop — until the laptop dies
✓ This course connects your repo to a remote: you'll add a remote, push your history so it's backed up and shareable, clone it into a second copy, and keep both in sync with fetch and pull — the exact push/pull/clone workflow every team uses on GitHub, learned here with zero account and zero network
✓ Runs free in your browser

Git · 4 — Collaborative Workflows

Git · Intermediate

✓ Work like a team, not a solo hacker
✓ By the end you can run the feature-branch (pull-request) workflow every engineering team uses: branch off main, write reviewable commits, review changes by diff, integrate with a --no-ff merge, rebase a stale branch onto the latest main, and cherry-pick a single hotfix
✓ These are the exact git moves behind the GitHub 'Pull Request' button

Git · 5 — Advanced

Git · Intermediate

✓ Every developer eventually makes a mess — a tangle of WIP commits, a change committed to the wrong branch, work reset away by accident, a bug that appeared 'sometime last week'
✓ This course is the professional recovery kit: clean up history with interactive rebase, move commits with cherry-pick, park work with stash, un-delete commits with the reflog, and pinpoint the exact bad commit with bisect
✓ Runs free in your browser, no account needed

Git · 6 — Quiz & Capstone

Git · Intermediate

✓ The finale of the Git path — prove it end-to-end
✓ You answer every interview-style question by DOING it on a real repository (count the commits, name the first one, branch to spec, read the remote's tip, mine the history), then ship a feature solo in a graded capstone: build it on a branch, merge it --no-ff, push it, and tag the release
✓ No new theory — this is where scattered skills become a proven, interview-ready engineer

GitHub Actions · 1 — Foundations

GitHub Actions · Beginner

✓ Automate everything
✓ By the end you can write a GitHub Actions workflow and RUN it — triggers, jobs, steps, checking out code, and running commands — all locally with no GitHub account
✓ You'll watch your pipeline actually execute, not just read YAML

GitHub Actions · 2 — CI Pipelines

GitHub Actions · Beginner

✓ Turn a single job into a real CI pipeline
✓ By the end you can lint + test in one job, fan out across versions with a matrix, order jobs with needs, pass data between jobs with outputs, and gate steps with conditionals — and you RUN every one locally with act, no GitHub account
✓ You watch multi-job pipelines actually execute

GitHub Actions · 3 — CD & Deployments

GitHub Actions · Intermediate

✓ CI proves your code works — CD delivers it
✓ By the end you can build a Continuous Deployment pipeline: a deploy job gated behind a build, secrets injected safely, environments, passing an image tag from build to deploy, and deploying only on a push to main — all run for real locally with act, no GitHub account and no cloud bill
✓ Runs free in your browser

GitHub Actions · 4 — Advanced

GitHub Actions · Intermediate

✓ Author like a platform engineer
✓ By the end you can factor a workflow into a reusable workflow called with inputs, read the github/runner contexts, gate steps with functions like success() and always(), build your own composite action, and keep a pipeline green with continue-on-error and step outputs — every pattern RUN for real locally with act, no GitHub account
✓ You watch advanced features actually execute

GitHub Actions · 5 — Quiz & Capstone

GitHub Actions · Intermediate

✓ The finale of the GitHub Actions path — prove it end-to-end
✓ You answer every question by DOING it: write a workflow to a spec and watch it RUN (basics, triggers, checkout & CI, env/secrets), then build two complete pipelines solo in a graded capstone — a green CI pipeline and a gated build→deploy CD pipeline
✓ No new theory; this is where scattered skills become a proven, interview-ready engineer

Using Amazon Bedrock for Content Moderation

AI/ML · Beginner

✓ In this Cloud Lab, you’ll learn to create a content moderation system using Amazon Bedrock by integrating AWS services like EventBridge, SQS, Lambda, S3, and DynamoDB

Identity Verification Using Amazon Rekognition

AI/ML · Intermediate

✓ Build a real-world facial recognition login system
✓ Learn to use Amazon Rekognition, S3, EC2, and API Gateway to create a secure Flask application that verifies users based on their images

Retrieval-Augmented Generation (RAG) with Amazon Bedrock

AI/ML · Intermediate

✓ Unlock the power of RAG
✓ Learn how to build an Amazon Bedrock Knowledge Base using S3 for data and Aurora PostgreSQL as a vector store to create intelligent, context-aware AI applications

AWS Cloud Computing Essentials

Compute · Beginner

✓ Go from zero to hero by learning the fundamentals of cloud computing
✓ Get hands-on with core AWS services like S3, EC2, and Lambda to build and deploy real applications

Configuring a Static Website with S3 and CloudFront

Storage & CDN · Beginner

✓ Learn to host a production-ready static website using Amazon S3 for storage and CloudFront as a global CDN
✓ Master Origin Access Control (OAC) for secure content delivery

Getting Started with Virtual Private Cloud (VPC) in AWS

Networking · Beginner

✓ Build your own secure corner of the AWS cloud
✓ Learn to create VPCs, configure public & private subnets, manage routing, and control internet access for your EC2 instances

Working with NoSQL Databases: A Beginner's Guide to AWS DynamoDB

Database · Beginner

✓ Go from zero to hero by learning the fundamentals of Amazon DynamoDB
✓ Get hands-on with creating tables, adding data, and optimizing read performance with Queries, Scans, and Secondary Indexes

Getting to Know AWS Lambda

Serverless · Beginner

✓ Dive into serverless
✓ Learn to create, configure, invoke, and manage AWS Lambda functions using the console, Function URLs, S3 triggers, and SDKs
✓ Master versions and aliases for smooth deployments

Attach an Application Load Balancer to EC2 Auto Scaling Group

Networking · Beginner

✓ Learn how to automatically distribute web traffic
✓ Build a resilient setup using an Application Load Balancer (ALB) connected to an EC2 Auto Scaling Group (ASG) for high availability

Docker · 1 — Container Foundations

Docker · Beginner

✓ You've heard of Docker — now run your first container in 60 seconds
✓ By the end you can run, tag, exec into, port-map, inspect and reason about any container, and you'll understand what makes a container isolated
✓ No prior Docker (or Linux depth) needed

Docker · 2 — Building Images

Docker · Beginner

✓ You can run containers — now build your own
✓ Take a real app (the DeployU Notes API) and package it into a Docker image: write a Dockerfile, master CMD vs ENTRYPOINT, use layer caching and
✓ dockerignore, go multi-stage, add build args and labels, and shrink a 1

Docker · 3 — Sharing Images & Registries

Docker · Beginner

✓ You can build images — now share them
✓ Take the DeployU Notes API image you built in Course 2 and get it off your laptop: give it a registry-style name, run your OWN private registry in one command, push and pull the image, understand immutable digests vs mutable tags, and publish multiple versions you can browse over the Registry API
✓ By the end you can publish and deploy an image the way real teams do

Docker · 4 — Data & Persistence

Docker · Intermediate

✓ Your containers are stateless — restart one and its data is gone
✓ This course fixes that
✓ Take the DeployU Notes API (now writing notes to a file) and make its data survive: see why container storage is ephemeral, use named volumes for durable data, bind mounts for live local development, and tmpfs for sensitive in-memory data

Docker · 5 — Container Networking

Docker · Intermediate

✓ Two containers, one app: make them talk
✓ Take the DeployU Notes app — a public API and a separate database service — and wire them together the real way
✓ Learn why names don't resolve on the default bridge, fix it with a user-defined network + built-in DNS, publish a port to reach the app, inspect and troubleshoot connectivity with netshoot, and contrast host vs none network modes

Docker · 6 — Docker Compose

Docker · Intermediate

✓ Stop juggling docker run flags — describe the whole app in one file
✓ Take the DeployU Notes stack (a database service, a public API, and a web frontend) and orchestrate all three with Docker Compose: write a compose
✓ yaml, add depends_on with a healthcheck, get service-name networking for free, wire a named volume and environment, publish the frontend, and master the everyday compose workflows (logs, ps, down, overrides)

Docker · 7 — Security & Production

Docker · Intermediate

✓ You can build lean images — now make them safe to ship
✓ Take the DeployU Notes API and harden it end-to-end: run it as a non-root user, scan it for vulnerabilities with Trivy, keep secrets OUT of your image layers, cap its memory and CPU, add a real HEALTHCHECK, and combine everything into a production run posture (read-only root, dropped capabilities, restart policy)
✓ By the end you ship a hardened, self-healing, least-privilege container

Docker · 8 — Capstone: Ship the Notes Platform

Docker · Intermediate

✓ The finale of the Docker path — ship a whole app, not a toy
✓ Take the three-service DeployU Notes Platform (a durable datastore, a public API, and a web frontend) and deliver it end-to-end, applying everything from Courses 1–7: containerize all three, orchestrate them with Compose, make the data durable with a named volume, harden the stack (non-root, healthchecks, resource limits), and ship the whole thing with one command
✓ Each milestone is a goal graded by real behavior, with a revealable solution — culminating in a capstone where you bring the entire platform up, durable and hardened, in a single command

Docker Mastery Quiz

Docker · Intermediate

✓ Test your Docker knowledge with 18 hands-on discovery questions
✓ Explore the pre-configured environment and answer based on what you find
✓ Pass with 80% to earn your Docker certification

Kubernetes · 1 — Foundations

Kubernetes · Beginner

✓ You just got a real Kubernetes cluster — now learn to run workloads on it
✓ By the end you can read a cluster with kubectl, run your first Pod, declare one in YAML, isolate work with namespaces, and give a Pod production-grade health probes and resource limits
✓ No prior Kubernetes needed

Kubernetes · 2 — Workloads

Kubernetes · Beginner

✓ You can run a Pod — now run fleets of them that heal, scale, and update with zero downtime
✓ By the end you can create a self-healing ReplicaSet, manage apps declaratively with Deployments, scale on demand, ship a rolling update, and roll back a bad release — all on a real Kubernetes cluster driving the podinfo app
✓ Everything runs free in your browser — no install, no cloud account

Kubernetes · 3 — Services & Networking

Kubernetes · Intermediate

✓ Pods are disposable and their IPs change constantly — so how does anything stay reachable
✓ Learn the networking layer that makes Kubernetes usable: give a Deployment a stable address with a ClusterIP Service, find it by cluster DNS, publish it on a NodePort, and route real HTTP traffic to it by hostname with an Ingress (Traefik)
✓ By the end you can expose and connect workloads the way every production cluster does

Kubernetes · 4 — Configuration

Kubernetes · Intermediate

✓ Never bake config into an image again
✓ You'll externalise podinfo's settings the professional, 12-factor way: plain environment variables, then ConfigMaps (as env vars and as mounted files), then Secrets (kept out of plaintext), and finally a Deployment that reads a ConfigMap and a Secret at the same time
✓ podinfo echoes its config back over HTTP, so you SEE every value land

Kubernetes · 5 — Storage

Kubernetes · Intermediate

✓ Pods are throwaway — restart one and its files vanish
✓ Learn to give Kubernetes workloads durable storage: an emptyDir scratch volume, a PersistentVolumeClaim, and the proof that matters most — data that survives a pod restart
✓ You'll use StorageClasses (k3s ships a default dynamic provisioner), mount a volume into your podinfo app, and finish by shipping a persisted store yourself

Kubernetes · 6 — Scheduling & Scaling

Kubernetes · Intermediate

✓ Run and scale work like a pro on a real Kubernetes cluster
✓ By the end you can select Pods with labels, run a batch Job to completion, schedule recurring work with a CronJob, size Pods with resource requests so the scheduler can place them, and autoscale podinfo with a HorizontalPodAutoscaler using live metrics
✓ Builds on the Kubernetes path

Kubernetes · 7 — Security & RBAC

Kubernetes · Intermediate

✓ Your cluster is running workloads — now lock it down like production
✓ You'll give an app its own identity with a ServiceAccount, grant least-privilege access with Roles + RoleBindings (and prove it with the real authorizer), harden a Pod to run as a non-root user, declare traffic isolation with a default-deny NetworkPolicy plus a scoped allow, and lock a container's root filesystem read-only
✓ Every step is verified against the live cluster — real RBAC decisions from the authorizer, real writes inside live containers, and correctly-declared network policy objects

Kubernetes · 8 — Observability & Troubleshooting

Kubernetes · Intermediate

✓ Troubleshooting is 30% of the CKA — this course drills the exact loop: break → diagnose → fix → prove healthy
✓ Read container logs, read Events and describe to explain WHY a workload won't start, fix a broken image tag and a broken health probe, exec into a debug pod to test service and DNS reachability, watch resource metrics with kubectl top, and finish by repairing a broken Deployment with no walkthrough
✓ Every fix is proven against the live cluster

Kubernetes · 9 — Production Practices

Kubernetes · Advanced

✓ You can run workloads on Kubernetes — now make them PRODUCTION-GRADE
✓ Enforce the measurable production checklist on podinfo (3+ replicas, health probes, resource requests+limits, a zero-downtime rollout), guard availability with a PodDisruptionBudget, cap a team namespace with a ResourceQuota, auto-fill defaults with a LimitRange, and package everything with Kustomize overlays
✓ These are the exact things senior engineers demand in review

Kubernetes · 10 — Quiz & Capstone

Kubernetes · Advanced

✓ The finale of the path
✓ Prove you can operate Kubernetes end-to-end: across six graded checkpoints you build ONE production podinfo stack in a real cluster — namespace + Pod, a 3-replica Deployment, a Service you can curl, ConfigMap-driven config, bound storage, and production hardening (resource limits, a PodDisruptionBudget, and an HPA)
✓ Then a final unaided capstone: stand up a complete production podinfo from scratch

Linux · 1 — Foundations

Linux · Beginner

✓ You just got your first Linux server — now learn to run it
✓ By the end you can move around the filesystem, read the map every Linux box shares (the FHS), create and organize files, and search real server logs
✓ No prior Linux needed

Linux · 2 — Shell & Text Power

Linux · Beginner

✓ Turn a wall of log text into answers
✓ By the end you can wield redirection, pipes, grep, cut, sort/uniq, sed and awk to analyse real server logs the way working engineers do — finding the top attacker, counting errors, and building a report in one line
✓ Everything runs free in your browser

Linux · 3 — Users & Permissions

Linux · Intermediate

✓ Turn your one-user box into a secure, multi-user server
✓ By the end you can onboard a team with users and groups, take ownership of files, lock them down with chmod (numeric and symbolic), wield setgid/sticky/ACLs for shared work, and grant a scoped privilege the professional way — by authoring /etc/sudoers
✓ d and validating it with visudo

Linux · 4 — Processes & Services

Linux · Intermediate

✓ Keep a Linux server alive
✓ By the end you can inspect and control running processes, send the right signal, run appbox as a real systemd service you author yourself, read its logs with journalctl, schedule work with cron, monitor CPU/memory/disk, and handle an incident when a runaway process appears
✓ This is the daily reality of ops — and it all runs free in your browser, no install, no cloud account

Linux · 5 — Networking

Linux · Intermediate

✓ Stop guessing whether a service is up — prove it
✓ By the end you can list exactly what's listening with ss, talk to a live service with curl, resolve names to addresses with DNS, and reason about a firewall with real iptables — the reachability triage every engineer runs when 'the service is up but I can't reach it
✓ ' Everything runs free in your browser — no install, no cloud account

Linux · 6 — Scripting & Automation

Linux · Intermediate

✓ Stop doing the same server chores by hand — teach the machine to do them
✓ By the end you can write real Bash scripts: shebang and exit codes, safe quoting, arguments, conditionals, loops and functions — and ship a health check and a backup tool for a live server
✓ Builds on Courses 1–5

Linux · 7 — Quiz & Capstone

Linux · Intermediate

✓ The finale of the Linux path — prove it end-to-end
✓ You answer every interview-style question by DOING it on a real server (count the traffic, secure a shared directory, run a service, confirm it's reachable), then administer appbox solo in a graded capstone: provision a reports pipeline, schedule it, and hand in a health report
✓ No new theory — this is where scattered skills become a proven, interview-ready engineer

Terraform · 1 — Infrastructure as Code Foundations

Terraform · Beginner

✓ Provision your first real infrastructure in 60 seconds — no cloud account, no bill
✓ Build the StreamVerse project from an empty directory: write HCL, run the full init → plan → apply → destroy loop, generate a real file on disk that Terraform manages, read and trust the state, manage change safely, and prove idempotency with `plan -detailed-exitcode`
✓ Uses the zero-cost `random` + `local` providers so everything runs free, offline, in your browser

Terraform · 2 — The Configuration Language

Terraform · Beginner

✓ Stop hardcoding
✓ Take the StreamVerse project you built in Course 1 and make it reusable: replace magic strings with typed, validated input variables; master variable precedence (
✓ tfvars, TF_VAR_, -var); compute derived values with locals; expose results with outputs (including sensitive ones the CLI masks); transform data with expressions and built-in functions like format/upper/join/jsonencode; and generate one resource per service with count and for_each

Terraform · 3 — Providers & Real Infrastructure

Terraform · Intermediate

✓ Provision REAL cloud infrastructure — with no cloud account and no bill
✓ Configure a genuine `provider "aws"` against LocalStack (a real AWS API running right in your lab) and create real `aws_s3_bucket`, `aws_vpc`, `aws_subnet`, and `aws_instance` resources, then cross-check every one with the AWS CLI
✓ Watch a single `terraform apply` manage AWS AND a live Docker container side by side — proof that Terraform drives ANY provider the same way

Terraform · 4 — State Management

Terraform · Intermediate

✓ State is the beating heart of Terraform — and this is where you stop fearing it
✓ Inherit StreamVerse's running edge stack and bring every piece of it under control: inspect state as queryable JSON, rename a resource with `state mv` (no destroy/recreate), `state rm` and re-adopt without downtime, `terraform import` an out-of-band container Terraform never created, detect drift measurably with `plan -detailed-exitcode` (2 → heal → 0), and read another config's outputs via `terraform_remote_state`
✓ Real containers you `docker ps` and `curl`, 100% offline — no cloud account, no bill

Terraform · 5 — Modules

Terraform · Intermediate

✓ Stop copy-pasting resource blocks — package infrastructure once and reuse it everywhere
✓ Author your own local `web-service` module, instantiate it, wire its outputs into other resources, then stamp out a whole fleet of real running containers with a single `for_each`
✓ Refactor safely with a `moved` block (rename with zero downtime), add input validation, and learn how module sources & versions work

Terraform · 6 — Production Workflow at Scale

Terraform · Advanced

✓ Run Terraform the way real teams do
✓ Enforce the `fmt → validate → plan → apply` gate before every change, then ship the SAME StreamVerse code to `dev` and `prod` using workspaces — isolated state per environment, with `terraform
✓ workspace` making names and ports env-aware so both fleets run side by side without collisions

Terraform · 7 — 🎓 Capstone: The StreamVerse Edge Stack

Terraform · Advanced

✓ Ship a complete, production-shaped stack with ONE tool — no cloud account, no bill
✓ Compose everything you've learned into a real multi-provider system: generate a TLS key + self-signed cert with Terraform, render an nginx
✓ conf from live state, run an edge reverse-proxy that proxies `/api` to an app container built from your own module, then prove it end-to-end with `curl`

MERN Project · 8 — Deploy It Live (Docker)

DevOps · Intermediate

✓ Your app works in the lab — now make it real
✓ In this module you turn CineList into a single deployable product: build the React frontend, serve it from your Express server so the whole thing runs on one URL, configure it with environment variables (no hardcoded secrets), and package it with a Dockerfile ready to push to a host
✓ By the end you have a real, deployable full-stack app for your resume

MERN Project · 5 — Add a Database (MongoDB)

MongoDB · Intermediate

✓ Your API works — but restart the server and everything's gone
✓ Real apps remember
✓ In this module you give CineList a real database with MongoDB and Mongoose: you make data permanent, set rules so bad data can't sneak in, ask sharp questions with queries and filters, connect movies to their reviews, and turn raw rows into insight with aggregation

Start Lab

→