Interactive Courses

Visualise How Things Actually Work

Each course includes interactive simulators that let you step through invisible mechanics and see how systems actually work under the hood. No fluff. No 40-hour marathons. Just deep understanding.

Interactive Simulators Under the Hood Mental Models Step-by-Step No Fluff
ai agents agent loop tool governance agent memory recoverable execution
Interactive Labs

Engineering AI Agents

Bounded tool-using loops with durable state, guardrails, and evals

Learn how an AI agent actually runs: a model choosing actions in a loop that your application code executes, bounds, and stops. This Deep Dive covers least-privilege tool contracts and approval gates, plans that survive failed assumptions, memory with provenance and deletion boundaries, checkpointed execution that recovers without repeating unsafe side effects, and evaluations that turn recorded runs and fault-injected trials into success rates you can trust.

Hands-on labs
Start Simulating View Curriculum
event loop promises async await microtasks cancellation
Interactive Labs

Async JavaScript

Event-loop ordering, promise control flow, cancellation, and bounded concurrency

Async JavaScript is a Deep Dive into the mechanics that decide which callback, microtask, or awaited continuation runs next, and why. You trace run-to-completion execution, task and microtask ordering, promise resolution through chains, and await suspension across interleaved async functions, then apply that model to choose combinators, cancel obsolete work with AbortController, consume streams with backpressure, and build a bounded scheduler that survives partial failure.

Hands-on labs
Start Simulating View Curriculum
authentication oauth passkeys jwt oidc
Interactive Labs

Modern Authentication

Sessions, passkeys, delegated authorization, tokens, and single sign-on

Learn how modern login actually works, from session cookies and passkeys to OAuth delegation, PKCE, JWT validation, OpenID Connect, and single sign-on. Trace each flow across browser and server, understand the attacks each protocol binding blocks, and design token custody and session boundaries you can defend in a security review.

Hands-on labs
Start Simulating View Curriculum
domain-driven design bounded contexts aggregates ubiquitous language context maps
Interactive Labs

Domain-Driven Design, Applied

Turn business rules into boundaries, models, and maintainable code

Learn to build software that stays aligned with the business it serves, instead of drifting away from it. You will extract a ubiquitous language from concrete business scenarios, draw bounded contexts and map the relationships between them, then design small aggregates that enforce invariants, keep persistence behind the model, and connect models with domain events while making eventual consistency explicit.

Hands-on labs
Start Simulating View Curriculum
event-driven transactional outbox idempotency message queues event streams
Interactive Labs

Event-Driven Architecture

Build evolvable asynchronous flows without hiding delivery and consistency costs

Learn to design asynchronous systems where services exchange commands and events through queues and streams, and to keep them correct when messages arrive twice, out of order, or after an ambiguous failure. You will build idempotent handlers, replace unsafe dual writes with the transactional outbox, coordinate workflows with compensation, evolve message contracts without breaking consumers, and diagnose stuck flows in production without repeating external effects.

Hands-on labs
Start Simulating View Curriculum
next-token prediction tokenization self-attention transformers rlhf
Interactive Labs

How LLMs Actually Work

From tokenized text to trained parameters and next-token generation

Trace the full path from raw text to generated answer: how a tokenizer splits your prompt, how self-attention builds context-dependent representations, how next-token prediction and gradient descent turn data into parameters, and how post-training reshapes a base model into an assistant. You finish able to reason about token costs, sampling settings, context limits, and hallucination as consequences of the mechanism, not as mysteries.

Hands-on labs
Start Simulating View Curriculum
kubernetes pods scheduling services rollouts
Interactive Labs

Inside Kubernetes

Run resilient workloads across scheduling, networking, storage, and failures

This Deep Dive follows a workload from YAML manifest through the control plane, scheduler, kubelet, Service network, and persistent storage to a running container, then puts it under rollouts, preemption, node drains, and failed mounts. You learn to predict where a Pod lands, which Pods survive eviction, how traffic reaches an endpoint, and which cluster evidence points to the fix when a workload stays Pending or in CrashLoopBackOff. Only container image and runtime basics are assumed.

Hands-on labs
Start Simulating View Curriculum
mcp stateless protocol typed tools streamable http oauth
Interactive Labs

MCP for Engineers

Build stateless servers with typed tools, live context, and secure access

Learn the Model Context Protocol from its stateless 2026-07-28 model outward: hosts, clients, servers, and the JSON-RPC requests that connect them without an initialization handshake or connection state. You build typed tools, addressable resources, and reusable prompts, run them over STDIO and Streamable HTTP, and protect them with OAuth, per-request authorization, and deterministic abuse tests. This Deep Dive is for engineers who need servers that stay correct when connections drop and processes restart.

Hands-on labs
Start Simulating View Curriculum
system design trade-offs capacity estimation storage decisions caching
Interactive Labs

System Design Fundamentals

Turn requirements into explicit, defensible architecture trade-offs

Learn to turn an ambiguous product request into a defensible architecture: scoped requirements, capacity estimates that expose bottlenecks, a serving path that survives overload, storage and caching chosen from real access patterns, and queues with honest delivery semantics. Every decision traces back to a requirement, a constraint, or a measured limit, so you can defend the design in a review instead of reciting patterns.

Hands-on labs
Start Simulating View Curriculum

All courses included with your subscription. Not sure where to start? Follow a learning path.

View Pricing Plans