Upskill yourself across a variety of courses.
2h 58m
Think like an attacker, code like a defender. This course builds the security instincts every professional engineer needs. You'll start with the web threat model, the CIA triad, and the attacker mindset, then work the OWASP Top 10 (2025) end to end: authentication and session security (bcrypt/argon2, secure cookies, MFA, credential stuffing), broken access control and IDOR, injection (SQL and command) and why parameterization stops it, XSS and CSRF and Content-Security-Policy, cryptography basics with TLS and secrets management, dependency and supply-chain security (SCA/SBOM), and security testing (SAST/DAST) inside a secure SDLC. Every vulnerability is taught defensively — you learn how an attack works only so you can prevent it, and every example ends in the fix. The capstone hardens a deliberately vulnerable app end to end. Assumes basic web and HTTP knowledge; no prior security experience required.
3h
Ship real iOS and Android apps from one React codebase. Starting from an Expo project, you'll learn the core native components (View, Text, Image, ScrollView) and how they differ from web React, styling and layout with Flexbox and StyleSheet, navigation with Expo Router, state and data fetching with loading/error states, persistent storage, high-performance lists with FlatList, native device APIs (camera, location, permissions), forms and gestures, and testing with React Native Testing Library — finishing by building and publishing a complete app. Assumes you already know React (hooks, JSX, state) from the React & Modern Frontend course; this one teaches the mobile/native layer on top.
3h 10m
Master non-relational data. This course starts with when and why NoSQL exists and the CAP tradeoffs, walks the four NoSQL families (document, key-value, column-family, graph), then goes deep on two workhorses. With MongoDB you'll learn documents and BSON, CRUD and the query language, embedding vs referencing and schema-design patterns, indexes and query plans, the aggregation pipeline, and multi-document transactions — all in mongosh. With Redis you'll learn the in-memory key-value model and every core data structure (strings, lists, sets, sorted sets, hashes, streams), caching patterns with TTL and eviction, pub/sub, MULTI/EXEC transactions, RDB vs AOF persistence, and replication and Cluster scaling. It finishes with a polyglot-persistence capstone that uses SQL, MongoDB, and Redis each for the job it does best. Complements the SQL course; assumes basic database familiarity.
3h 12m
Build real predictive models from the ground up. You'll start with the ML mindset and workflow — what learning from data actually means, and when NOT to reach for ML — then wrangle and explore data with pandas and NumPy. From there you train your own supervised models (linear and logistic regression, gradient descent, k-nearest neighbours, decision trees), evaluate them honestly (train/validation/test, cross-validation, precision/recall/F1, ROC-AUC, the bias-variance tradeoff, overfitting, regularization), engineer features and assemble leak-free scikit-learn Pipelines, then move to unsupervised learning (k-means, PCA) and finally neural networks with PyTorch — finishing with an end-to-end capstone that saves and serves a trained model. This is classical, foundational machine learning: you train the models yourself. It assumes Python basics (see the Python course) and teaches the ML on top.
3h 14m
Become fluent and fast at the Linux shell. Starting from what Linux and the shell actually are, you'll learn to open a terminal, read the prompt, and move around the filesystem hierarchy with pwd, cd, and ls using absolute and relative paths. Then you'll manipulate files (touch, cp, mv, rm, mkdir), view them (cat, less, head, tail), and hunt them down (find, locate, globbing). From there: the permission model (rwx, chmod symbolic and octal, chown, sudo, root), the standard streams with pipes and redirection (stdin/stdout/stderr, >, >>, 2>, |, tee, exit codes, && and ||), and the text-processing power tools (grep with regex, cut, sort, uniq, wc, tr, and an intro to sed and awk). You'll manage processes, jobs, and signals, and services with systemd; install software with apt and dnf; and use the networking tools every engineer needs (ssh with keys, scp, curl, wget, ping, ss, dig). The course finishes with Bash scripting — variables and quoting, conditionals, loops, functions, and set -euo pipefail — and a capstone where you write a real, robust automation script. No prior Linux experience is assumed; everything uses bash on a modern distribution.
3h 14m
A complete, hands-on journey through modern Go (Go 1.22+) — from your first `go run` to a production-grade concurrent HTTP service. You'll install the toolchain and modules, then master the language: variables and types, constants and iota, control flow, functions with multiple returns, and Go's idiomatic error handling with wrapping. From there you build fluency with slices, maps, strings and runes, then structs, methods, interfaces, and composition. The back half is where Go shines — goroutines, channels, select, the sync and context packages, and the race detector — followed by the standard library (encoding/json, net/http, io), testing with table-driven tests and benchmarks, and the modules-and-tooling workflow. It finishes with a capstone: a real concurrent REST API with routing, graceful shutdown, a worker pool, and tests. Assumes general programming experience; no prior Go required.
3h 18m
Version control from your first commit to confident team collaboration. You'll build the mental model that makes Git click — the object model, the three areas (working tree, staging area, repository), and branches as movable pointers — then practise the everyday cycle of staging and committing, inspecting history and diffs, and ignoring files. From there you branch and merge, work with remotes (clone, fetch, pull, push, tracking branches), and run the full GitHub pull-request and code-review workflow. The back half is the confidence-building material most tutorials skip: resolving merge conflicts, rewriting history with interactive rebase and cherry-pick, and undoing mistakes safely with restore, reset, revert, and the reflog. You finish with team workflows — branching strategies, tags and semantic-versioned releases, and a first GitHub Actions CI pipeline. Prose, real terminal sessions, an in-browser git sandbox, output-prediction drills, ordering and matching activities, checklists, and mentor-chat prompts rehearse every skill in the format that fits it. No prior version-control experience assumed.
3h 2m
Move and transform data reliably at scale. Starting from what the data-engineering role actually is, you'll map the modern data stack and the batch-vs-streaming, OLTP-vs-OLAP divides. Then you'll model data for analytics with dimensional star and snowflake schemas, facts and dimensions, and slowly changing dimensions, and choose between a warehouse, a lake, and a lakehouse (with columnar Parquet under the hood). You'll write advanced analytical SQL — window functions, CTEs, grouping sets, and partition-aware performance — then build transformations the modern way: ETL vs ELT, a dbt-style project of models and tests, and idempotent incremental models. From there you scale out with distributed batch processing in Spark (DataFrames, partitions and shuffles, transformations vs actions, lazy evaluation), move to streaming with Kafka (topics, partitions, consumer groups, delivery semantics, event-driven pipelines), orchestrate everything with Airflow (DAGs, scheduling, backfills, idempotency, retries, sensors), and make it trustworthy with data contracts, tests, freshness and volume checks, lineage, and governance. The capstone ties it together into an end-to-end batch + streaming pipeline that is orchestrated and tested. Assumes working SQL and basic Python (see the SQL and Python courses); this one teaches the data-platform layer on top.
2h 57m
The computer-science fundamentals every technical interview probes, taught from the ground up and kept language-agnostic. You'll learn what an operating system actually does — the kernel/user-mode split, system calls, and the abstractions it sells you (processes, files, virtual memory) — then go deep on processes versus threads and the cost of a context switch, CPU scheduling (FCFS, round-robin, priority, MLFQ) and the throughput/latency/fairness tradeoffs, and memory management: physical versus virtual memory, paging, page tables, the TLB, page faults, and the stack versus the heap. From there you tackle concurrency: concurrency versus parallelism, shared state and race conditions, critical sections, mutexes, semaphores and atomicity, then deadlocks — the four Coffman conditions and how to prevent, avoid, or detect them — plus the producer-consumer and readers-writers patterns. The networking half builds the stack from the wire up: the layered model, IP addressing, TCP versus UDP, the three-way handshake and reliability, ports and sockets, then DNS resolution, HTTP/HTTPS, the TLS handshake, and load balancing. It closes with a capstone that traces exactly what happens when you type a URL and press Enter, and a small threaded producer-consumer project you reason about end to end. Short illustrative snippets (C, Python, shell) make the ideas concrete; no single language is assumed.
3h 10m
Modern C++ (C++17/20) from your first compile to systems-level fluency. You'll start with the toolchain — g++/clang++, the compile-vs-link pipeline, and CMake — then master the language core: fundamental types, references, const/constexpr and auto, control flow, and functions with overloading and scope. From there you go where C++ actually lives: pointers, the stack-vs-heap distinction, and the RAII discipline with unique_ptr/shared_ptr that replaces manual new/delete. You'll write real classes with the rule of 0/3/5 and operator overloading, then move up the abstraction ladder to templates and generic programming, the STL (containers, iterators, algorithms, and lambdas), move semantics and the modern idioms (structured bindings, std::optional, perfect forwarding), and concurrency with threads, mutexes, and futures — finishing with a real multithreaded project. The result is C++ you can defend in a technical interview and use in competitive programming. Assumes general programming experience (variables, loops, functions in some language); it does not assume prior C or C++.
3h
The behavioral round decides more offers than most candidates realize — and it is the round people prepare for least. This course teaches what interviewers actually assess behind the friendly questions, the STAR method for structuring crisp, high-impact answers, and how to build a small, reusable story bank mapped to the core competencies so you are never caught without an example. You'll practice the common questions (tell me about yourself, teamwork, conflict, leadership, initiative, difficult people) and the hard ones (biggest failure, real weakness, disagreeing with a manager, ethical dilemmas, ambiguity, employment gaps and layoffs), then work through values- and leadership-principle interviews (Amazon-style LPs and their equivalents). From there you'll sharpen communication and executive presence — clarity, concision, storytelling, body language, listening, remote/video interviews, and handling nerves — and learn salary negotiation and how to evaluate an offer holistically, not just by the number. It finishes with a full mock-interview walkthrough with model answers and a personal, week-by-week preparation plan. Every skill is rehearsed in the format that fits it: annotated sample answers, MCQs that make you spot the strongest answer or the red flag, drafting drills with rubrics, ordering and matching activities, a STAR story-builder, prep checklists, and mentor-chat rehearsals. No prior interview experience assumed; honest, modern advice with no fabricated statistics or fake company policies.
2h 50m
Build production HTTP APIs with Node.js (Node 22 LTS) and Express 5. Covers the Node runtime and event loop, modules and npm, the HTTP protocol and REST design, Express routing and middleware, input validation and centralized error handling, persistence with a real database (PostgreSQL via Prisma), authentication and authorization (sessions vs JWT, password hashing, RBAC), async patterns/streams/caching/rate-limiting, and testing APIs — finishing by building and deploying a full REST API. Assumes JavaScript/TypeScript fundamentals (see the JS/TS course); this one teaches the server on top.
2h 54m
Cloud computing from first principles to deploying a resilient application on AWS. You'll start with what the cloud actually is — on-prem versus cloud, the IaaS/PaaS/SaaS models, and the AWS global infrastructure of Regions, Availability Zones, and edge locations — then set up an account safely with the Console, the AWS CLI, and billing guardrails. From there you build up the core: the shared-responsibility model and IAM least privilege; compute (EC2, Lambda and event-driven serverless, ECS/Fargate containers); storage (S3 with its classes and lifecycle, EBS versus EFS, encryption); networking (VPC, public and private subnets, security groups versus NACLs, load balancers, and Route 53 DNS); and databases (RDS, DynamoDB, ElastiCache). The advanced modules cover infrastructure as code and deployment (CloudFormation and Terraform, immutable infra, CI/CD, blue/green) and operations (CloudWatch, CloudTrail, the six-pillar Well-Architected Framework, and cost optimization) — finishing with a capstone that ties a VPC, an Application Load Balancer, an Auto Scaling group, RDS, S3, and IAM into one multi-tier web app. It maps to the mindset behind the AWS Certified Cloud Practitioner exam. No prior cloud experience assumed; comfort reading a terminal helps.
2h 42m
A taught high-level-design course that turns the intimidating open-ended interview into a repeatable engineering method. You'll learn a seven-step framework — clarify requirements, estimate, design the API, model the data, sketch the high-level architecture, deep-dive the hard parts, and hunt bottlenecks — and then apply it to the building blocks of every large system: back-of-the-envelope estimation, DNS and load balancing, SQL versus NoSQL and sharding, caching and CDNs, message queues and event streaming, the CAP/PACELC consistency spectrum and consensus, and the reliability patterns (rate limiting, idempotency, observability, graceful degradation) that keep it all up. It closes with full worked case studies — a URL shortener, a news feed, a chat system — and a capstone you design end to end on an embedded architecture canvas. Mixes prose, YAML/JSON API sketches, a Python capacity-calculation drill, MCQ tradeoff checks, ordering and matching activities, self-attestation checklists, and mentor-chat prompts so every skill is rehearsed in the format that fits it best.
2h 53m
A complete, hands-on journey through SQL and relational databases, taught on PostgreSQL 16/17 — from your very first SELECT to designing, indexing, and tuning schemas that hold up in production. You'll query with filters, joins, aggregation, subqueries and CTEs, and window functions; model data with normalization, keys, and constraints; read EXPLAIN ANALYZE plans and add the right indexes; and reason about transactions, ACID, and isolation levels. Mixes prose, runnable queries, MCQ checks, output-prediction drills, ordering and matching activities, an embedded SQL console, and mentor-chat prompts so every skill is rehearsed in the format that fits it best.
2h 52m
Build production user interfaces with React 19 and Next.js 15. Starting from your first component, you'll master JSX, props and composition, the re-render model, hooks (useState, useEffect, useRef, useMemo, useCallback, and custom hooks), Context, controlled forms, and data fetching with loading and error states. Then you move to the framework layer: the Next.js App Router, file-based routing and layouts, Server vs Client Components, rendering strategies (SSG, SSR, ISR, and streaming), performance and memoization, TypeScript for props and hooks, and testing with React Testing Library — finishing with a capstone app. Assumes you already know JavaScript and TypeScript (see the JS/TS course); this one teaches the framework on top.
3h 28m
A taught object-oriented and low-level design course that takes you from the four OOP pillars to full machine-coding case studies. You'll internalise encapsulation, abstraction, inheritance, and polymorphism; apply the five SOLID principles through before/after refactors; model requirements with UML class and sequence diagrams; wield the classic Gang-of-Four creational, structural, and behavioral patterns; design safely for concurrency; and finish with complete LLD walkthroughs of a parking lot and an elevator system plus a capstone design task. Every idea is written in modern, idiomatic Java (records, sealed types, enums, interfaces) and rehearsed through prose, runnable code, MCQ checks, output-prediction drills, ordering and matching activities, an embedded JShell sandbox, design checklists, and mentor-chat prompts — the format that fits each skill best. Assumes you can already program; teaches you to design.
2h 31m
A taught, from-scratch data-structures-and-algorithms course — the guided on-ramp you take before you start grinding a problem bank. We build complexity intuition first, then teach the recurring problem-solving patterns behind coding interviews: two pointers, sliding windows, hashing, fast/slow pointers, recursion and backtracking, tree and graph traversal, heaps, and dynamic programming. Code is in Python for clarity, but the goal is patterns you can carry to any language. Prose teaches the idea, worked examples show the idiomatic solution, and prediction drills, ordering and matching activities, an embedded REPL, and mentor prompts rehearse each skill in the format that fits it best. You leave able to reach for the right structure, name the time and space cost out loud, and recognise which pattern a new problem is really asking for.
2h 27m
A hands-on path from your first `docker run` to operating a cloud-native system end to end. You will build images with Dockerfiles, compose multi-container stacks, deploy to Kubernetes with pods, Deployments, Services, ConfigMaps and probes, ship code through a GitHub Actions pipeline, provision infrastructure as code with Terraform, and wire up observability and SRE practices. Prose, real manifests, an in-browser container terminal, prediction drills, ordering and matching activities, checklists, and mentor-chat prompts rehearse every skill in the format that fits it, building to a capstone where you containerize an app, wire CI/CD, and deploy it to a cluster.
2h 20m
A hands-on journey to building production applications on top of foundation models — Claude, GPT, and open models — rather than training them. You'll go from your first API call to a shipped, evaluated RAG-plus-agent system: prompting, structured outputs, tool use, embeddings, retrieval-augmented generation, agent loops, evals, and the cost, latency, caching, and safety concerns that separate a demo from production. Mixes prose, runnable Python, MCQ checks, prediction drills, ordering and matching activities, a prompt playground, an embedded REPL, engineering checklists, and mentor-chat prompts so every skill is rehearsed in the format that fits it best. Assumes Python basics; teaches the application layer, not model internals.
4h 8m
A complete, hands-on journey from your first Node.js install to shipping an idiomatic, fully typed, tested TypeScript application. Built on Node.js 24 (the current LTS), ECMAScript 2025, and TypeScript 6, it mixes prose, runnable code, MCQ checks, output-prediction drills, ordering and matching activities, an embedded sandbox, environment checklists, and mentor-chat prompts so every skill is rehearsed in the format that fits it best. You start in plain JavaScript, then layer TypeScript on top the way real teams do.
4h 4m
A complete, hands-on Java journey from your first JDK install to shipping an idiomatic, tested, concurrent command-line application. Built on Java 25 (LTS), it mixes prose, runnable code, MCQ checks, output-prediction drills, ordering and matching activities, an embedded JShell sandbox, environment checklists, and mentor-chat prompts so every skill is rehearsed in the format that fits it best.
3h 24m
A complete, hands-on Python journey from your first installation to building an idiomatic, tested, async-capable project. Mixes prose, runnable code, MCQ checks, prediction drills, ordering and matching activities, an embedded REPL, environment checklists, and mentor-chat prompts so every skill is rehearsed in the format that fits it best.
