Hands-on tutorials for Python, Java, React and many more, split into bite-sized segments. Read them as a page or swipe through them as shorts, in your language.
Free, hands-on tutorials in Python, Java, JavaScript, TypeScript, Angular, Node.js, DSA, system design, databases and Docker — as readable lessons or 30-second shorts, in English and Hindi.
Arduino & Embedded C — Program microcontrollers from first blink to interrupts: digital and analog I/O, PWM, UART/I2C/SPI, safe motor and power design, register-level embedded C, timers, sleep modes and ESP32 IoT projects. (25 lessons)
Bash / Shell Scripting — Write reliable Bash scripts: quoting, expansions, tests and loops, functions and arrays, redirection and pipes, strict mode, traps, ShellCheck and cron. (25 lessons)
C++ — Learn modern C++ (C++20/23): types, functions, pointers, RAII and smart pointers, classes and move semantics, the STL, templates, concepts and safe code. (25 lessons)
Dart — Learn Dart 3: sound null safety, records, patterns, sealed classes, mixins, async/await, streams, isolates, packages and testing, with the Flutter connection. (25 lessons)
C#/.NET — Learn C# and .NET in depth: types, OOP, records, generics, null safety, LINQ, async/await, concurrency, memory, exceptions and modern C# 14 features. (25 lessons)
Elixir & Phoenix — Learn Elixir and Phoenix: pattern matching, pipes, processes, GenServer, supervisors, Ecto, LiveView, PubSub, testing with ExUnit and deploying releases. (25 lessons)
Go (Golang) — Learn Go by running it: modules and packages, types and zero values, slices and maps, structs, interfaces and generics, errors, goroutines, channels, context, the race detector, net/http, JSON, testing and tooling, all executed with Go 1.27. (26 lessons)
Go Concurrency Patterns — A focused deep dive into Go concurrency: goroutines, channels, select, sync primitives, context cancellation, pipelines, worker pools, errgroup, graceful shutdown and race-free, leak-free production code. (25 lessons)
Haskell — Learn Haskell: pure functions, laziness, ADTs and type classes, Functor/Applicative/Monad, IO, STM concurrency, QuickCheck, parsers and web APIs. (25 lessons)
JavaScript Fundamentals: From Syntax to Async — Learn JavaScript from variables and functions to the DOM, classes, promises and modules. For beginners starting web development. (40 lessons)
Kotlin — Learn modern Kotlin from the basics to production: null safety, data and sealed classes, functional collections, coroutines and Flow, Java interop, testing and the server, Android and Multiplatform ecosystem. (25 lessons)
PHP — Learn modern PHP 8: strict types, match, enums, readonly classes, property hooks, PDO, security, Composer, PSR standards, Laravel/Symfony and deployment. (25 lessons)
Python Fundamentals: From Basics to Async — Learn Python from variables to classes, generators, decorators and async. For beginners and career switchers who want practical scripting and backend skills. (49 lessons)
R Programming — Learn R for data analysis: vectors, data frames, the tidyverse, dplyr and ggplot2, statistics and regression, Quarto reports, Shiny and reproducible workflows. (25 lessons)
Ruby — Learn Ruby 3: objects, blocks and lambdas, Enumerable, modules and mixins, pattern matching, metaprogramming and DSLs, gems, RSpec, YJIT and Rails basics. (25 lessons)
Rust — Learn Rust by compiling it: cargo, ownership and borrowing, lifetimes, structs, enums and traits, Result and the ? operator, iterators, fearless concurrency with Send and Sync, and testing with clippy and rustfmt, with real compiler output from Rust 1.99. (25 lessons)
Scala — Learn Scala 3: immutable collections, for comprehensions, traits, case classes and enums, pattern matching, givens, Futures, Cats Effect, sbt and Spark. (25 lessons)
Blockchain & Smart Contracts (Solidity) — Learn blockchain and Solidity: the EVM and gas, contract design, ERC-20 and NFTs, upgrades, oracles, security and audits, Foundry testing and dApps. (25 lessons)
Swift — Learn Swift 6: optionals, structs, enums, protocols, generics, closures, error handling, ARC, async/await, actors and data-race safety, with SwiftUI basics. (25 lessons)
TypeScript Fundamentals — Learn TypeScript types, generics and strict mode to catch bugs before runtime. A hands-on course for JavaScript developers. (28 lessons)
Zig — Learn Zig: explicit control flow, slices and pointers, errors and optionals, allocators, comptime generics, C interop, cross-compiling, build.zig and tests. (25 lessons)
Computer Science Fundamentals
Time & Space Complexity (Big-O) — Master Big-O analysis: growth rates, O, Omega and Theta, loops, recurrences and the master theorem, space, amortised analysis and practical optimisation. (25 lessons)
Data Structures in Python — Master data structures in Python: Big-O, lists, dicts and sets, deques and heaps, trees and tries, graphs, union-find, LRU caches and interview patterns. (25 lessons)
Database Fundamentals — Learn DBMS fundamentals: ER modelling, relational algebra, SQL, normalisation, transactions and ACID, concurrency control, recovery, indexing and CAP. (25 lessons)
Design Patterns — Learn the classic design patterns through realistic TypeScript examples: what each one is for, when it helps, when it is over-engineering, and the modern alternatives that often replace it. (25 lessons)
Functional Programming Concepts — Language-agnostic functional programming taught mainly in TypeScript: pure functions, immutability, composition, recursion and laziness, algebraic data types, Option and Result, functors and monads, and how to apply it all in real projects. (25 lessons)
Object-Oriented Programming (OOP) — Learn OOP the right way: classes and objects, encapsulation, abstraction, inheritance, polymorphism, composition, UML, SOLID, equals/hashCode and design. (25 lessons)
Frontend Development
Web Accessibility (A11y) — Build accessible websites with WCAG 2.2, semantic HTML, ARIA and keyboard patterns, and test with automated tools and screen readers. (26 lessons)
AI Visibility and LLM Brand Discovery — Learn how people discover brands through AI assistants and how to be found, cited and described accurately: crawlers, structured data, content, measurement and ethics. (25 lessons)
Angular Fundamentals: Components, Signals and Routing — Learn modern Angular with standalone components, templates, signals, routing, forms and HttpClient. For front-end developers building structured apps. (32 lessons)
Babel and SWC: JavaScript Transpilation and Build Speed — Learn how Babel and SWC transpile modern JavaScript, JSX and TypeScript, target browsers and Node, and speed up builds. For front-end and tooling developers. (31 lessons)
Next.js — Build full-stack React apps with the Next.js App Router: layouts, dynamic routes, Server and Client Components, static and dynamic rendering, caching, Server Actions, Route Handlers, Proxy, metadata and deployment, verified against a real Next.js 16 build. (25 lessons)
Progressive Web Apps: Offline, Installable Web Apps — Build installable, offline-capable web apps with manifests, service workers, caching and push. For front-end developers moving beyond static pages. (30 lessons)
React — Learn modern React by running it: JSX, components and props, state and batching, effects and data fetching, forms, reducers, context, custom hooks, refs, memoisation, keys, error boundaries and testing, with every example executed on React 19. (25 lessons)
React Native — Build native iOS and Android apps with React: core components, Flexbox layout, lists and input, navigation, data, device APIs, performance and shipping to the stores with Expo and EAS. (25 lessons)
Redux Toolkit / Zustand — Manage client state in React apps with Redux Toolkit, RTK Query and Zustand: slices, async logic, caching, selectors, middleware, testing and choosing the right tool. (25 lessons)
Responsive and Mobile-First Web Design — Build fluid, mobile-first layouts with media queries, Flexbox, Grid and container queries. For front-end developers who want sites that work on every screen. (26 lessons)
SEO for Developers: Technical SEO and Core Web Vitals — Learn technical SEO: crawlability, structured data, rendering and Core Web Vitals. For developers who want sites that rank and earn organic traffic. (34 lessons)
Storybook: Component-Driven UI Development — Build, document and test UI components in isolation with Storybook. For front-end developers and design-system teams working in React. (25 lessons)
Svelte / SvelteKit — Build fast web apps with Svelte 5 runes and SvelteKit 2: reactive components, snippets, shared state, filesystem routing, server data loading, form actions, adapters and testing. (25 lessons)
Tailwind CSS — Style interfaces directly in your markup with utility classes: layouts, responsive design, states, dark mode, design tokens and maintainable component patterns, using Tailwind CSS v4. (25 lessons)
Vue.js — Build modern web apps with Vue 3: templates and reactivity, components and composables, routing with Vue Router, state with Pinia, TypeScript, testing and performance. (25 lessons)
Web Performance Optimization — Measure and improve page speed with Core Web Vitals, DevTools and Lighthouse. Apply proven fixes for images, JavaScript, caching and delivery. (25 lessons)
Webpack: Module Bundling and Build Optimization — Learn to configure, optimize and debug Webpack builds for front-end projects. Ship smaller, faster bundles with a production-ready setup. (25 lessons)
Backend Development
API Design and Versioning — Design APIs people can rely on: resources, HTTP semantics, errors, pagination, idempotency, security, versioning, deprecation and governance, tested with a real running API. (27 lessons)
Authentication & Authorization — Build identity systems that hold up: password storage, sessions and cookies, JWTs, OAuth 2.0 and OpenID Connect, MFA and passkeys, and authorization models enforced in real APIs. (25 lessons)
Django / FastAPI — Build Python web backends two ways: FastAPI for typed, async APIs with Pydantic and dependency injection, and Django for full-stack apps with its ORM, migrations, forms and admin, with every example run on Django 6.1 and FastAPI 0.142. (26 lessons)
.NET Core: Build, Test and Ship Web APIs — Learn modern .NET from the CLI to ASP.NET Core APIs, dependency injection, EF Core, auth, testing and Docker. (26 lessons)
Fastify: Building High-Performance Node.js APIs — Build fast Node.js APIs with Fastify routing, JSON Schema validation, plugins, hooks and JWT auth. For developers who want an Express alternative. (32 lessons)
Firebase — Build apps on Firebase with the modular JavaScript SDK: Authentication, Firestore modelling and queries, Security Rules, Storage, Cloud Functions, Hosting and production practices. (25 lessons)
GraphQL — Design and build GraphQL APIs: schemas in SDL, queries and mutations, resolvers without N+1 problems, client caching, pagination, security limits and schema evolution. (25 lessons)
gRPC — High-performance service-to-service APIs: Protocol Buffers schemas, unary and streaming RPCs, deadlines and status codes, authentication and interceptors, load balancing and production practices. (25 lessons)
Apache Kafka: Event Streaming from Basics to Production — Learn Apache Kafka: topics, partitions, producers, consumer groups, delivery guarantees, retention, replication, exactly-once and operations, checked against a real broker. (25 lessons)
NestJS: Building Scalable Node.js APIs — Build structured, testable server-side apps with NestJS modules, dependency injection, TypeORM and guards. For TypeScript and Node.js developers. (34 lessons)
Node.js Fundamentals: Modules, Async and Servers — Learn Node.js from modules and npm to async code, streams and a basic HTTP server. For JavaScript developers moving to backend and tooling work. (30 lessons)
OpenAPI / Swagger — Describe HTTP APIs with OpenAPI 3.1: paths, parameters, schemas, security, errors, versioning, Swagger UI, linting, mocks, code generation and CI workflows. (25 lessons)
OWASP Top 10 — Understand the most critical web application security risks and how to prevent them, with vulnerable and fixed code side by side for access control, injection, cryptography, configuration, components, authentication and monitoring. (25 lessons)
RabbitMQ — Learn RabbitMQ 4.x: exchanges and routing, acks and prefetch, publisher confirms, dead-lettering and retries, quorum queues, streams, clustering and monitoring. (25 lessons)
WebSockets & Server-Sent Events — Learn real-time web communication: polling, Server-Sent Events, the WebSocket protocol, scaling with pub/sub, security and testing. (32 lessons)
Redis Pub/Sub & Streams — Build messaging on Redis: Pub/Sub, sharded channels, keyspace events, Streams, consumer groups, XACK and XAUTOCLAIM, trimming, durability and monitoring. (25 lessons)
REST API Design: Resources, Status Codes and Security — Design clean, predictable HTTP APIs: resources, status codes, pagination, versioning, authentication and errors. For backend and full-stack developers. (25 lessons)
Spring Boot — Build production-ready Java services with Spring Boot 4: starters and auto-configuration, dependency injection, REST controllers, validation, problem details, Spring Data JPA, transactions, slice tests and Actuator, verified with a real app built and run. (25 lessons)
Stripe Payments — Integrate Stripe end to end: Checkout and Payment Element, webhooks, SCA and saved cards, subscriptions, refunds and disputes, Connect, idempotency and a production checklist. (25 lessons)
Supabase — Build on Supabase: Postgres tables and supabase-js queries, Row Level Security, auth, storage, realtime, edge functions, the CLI workflow and a production-ready checklist. (25 lessons)
Databases & Data Stores
Elasticsearch — Build fast, relevant search and analytics: inverted indexes, mappings and analyzers, the Query DSL, aggregations, autocomplete and vector search, plus the operations that keep a cluster healthy. (25 lessons)
Hibernate / JPA — Learn JPA and Hibernate: entities, the persistence context, mappings, relationships, lazy loading and N+1 fixes, JPQL, transactions, locking and Spring Data. (25 lessons)
MongoDB Fundamentals: Documents, Queries and Indexes — Learn MongoDB from documents and CRUD to indexes, aggregation, schema design and replication. For developers building apps with flexible data. (23 lessons)
MySQL Fundamentals: SQL, Joins and Transactions — Learn MySQL and SQL from tables and queries to joins, indexes and transactions. For beginners and developers who need to work with relational data. (30 lessons)
Prisma / TypeORM / Sequelize — Learn Node.js ORMs the right way: Prisma, TypeORM and Sequelize models, relations, queries, migrations, transactions, performance and safe SQL. (35 lessons)
PostgreSQL — Learn PostgreSQL by running it: schema design and constraints, joins and aggregates, CTEs and window functions, JSONB, upserts, EXPLAIN and indexes, transactions and isolation, roles, row-level security and backups, all executed on PostgreSQL 16. (25 lessons)
SQL Deep Dive — Go beyond SELECT * : how SQL evaluates queries, joins without surprises, window functions, recursive CTEs, analytical patterns and index-friendly queries, with every query run on PostgreSQL 16. (25 lessons)
Vector Databases — Learn to store, index, filter and operate vectors in real systems: pgvector with SQL, Qdrant and Chroma APIs, HNSW tuning, filtered and hybrid search, sharding, replication, capacity planning, security and choosing a database, with every example run for real. (28 lessons)
DevOps, Cloud & Infrastructure
Ansible: Automate Servers with Playbooks — Learn agentless automation with Ansible: inventories, playbooks, variables, templates, handlers, roles, Vault and safe production rollouts, with real runnable examples. (26 lessons)
AWS Fundamentals: Core Services for Cloud Beginners — Learn core AWS services: IAM, EC2, S3, RDS, VPC, Lambda, CloudFront and CloudWatch, plus cost control. For beginners moving to the cloud. (28 lessons)
Azure — Learn Microsoft Azure from regions and RBAC to App Service, Functions, Cosmos DB, private networking, Bicep, monitoring and cost control. (25 lessons)
CI/CD Fundamentals: Pipelines, Testing and Deployment — Learn CI/CD concepts and GitHub Actions: pipelines, automated testing, environments, deployment strategies and secrets. For developers and DevOps beginners. (23 lessons)
Cloud Networking: VPCs, Subnets & Peering — From CIDR basics to VPCs, subnets, routing, NAT, security groups, peering, transit gateways, PrivateLink, hybrid links and troubleshooting. (33 lessons)
DevSecOps — Build security into every stage of delivery: threat modelling, secure coding, secret scanning, SAST, SCA, SBOMs, signed builds, containers, IaC and Kubernetes. (31 lessons)
Docker Fundamentals: Images, Containers and Compose — Learn Docker from images and containers to Dockerfiles, volumes, networking and Compose. For developers who want consistent environments. (28 lessons)
Docker Compose — Run multi-container apps with Docker Compose: services and builds, environment and interpolation, health checks and startup order, volumes, secrets, networks, override files and profiles, with every configuration checked by docker compose config. (25 lessons)
Google Cloud Platform — Learn Google Cloud from projects and IAM to Cloud Run, GKE, Pub/Sub, Cloud Storage, BigQuery, VPC networking, security and cost control. (25 lessons)
GitHub Actions — Automate CI/CD with GitHub Actions: workflow anatomy, triggers and filters, jobs and needs, matrices and expressions, caching and concurrency, token permissions, script injection, pinning, reusable workflows and deployments, with every workflow checked by actionlint. (25 lessons)
Helm — Learn Helm, the Kubernetes package manager: install and upgrade releases, write and template charts, use values, hooks and dependencies, and ship with GitOps. (25 lessons)
Kubernetes — Run containers reliably with Kubernetes: architecture, Pods and Deployments, Services, ConfigMaps and Secrets, scheduling and resources, probes, rolling updates, autoscaling, Kustomize, storage and security, with kubectl output and Python models run. (25 lessons)
Linux Command Line Fundamentals — Learn the Linux command line: files, permissions, processes, text tools, scripting, SSH and services. For developers and aspiring DevOps engineers. (31 lessons)
Nginx — Master NGINX: server blocks and location matching, static files, reverse proxying, load balancing, TLS with HTTP/2 and HTTP/3, caching, rate limits and logging. (25 lessons)
OpenTelemetry — Vendor-neutral observability: instrument services once for traces, metrics and logs, propagate context across services, and process telemetry with the OpenTelemetry Collector before sending it to any backend. (25 lessons)
Prometheus + Grafana — Monitor systems with metrics: instrument services, scrape them with Prometheus, query with PromQL, alert with Alertmanager and visualise everything in Grafana dashboards. (25 lessons)
Terraform — Manage infrastructure as code with Terraform: providers, resources, variables, plans, state and drift, count and for_each, modules, sensitive values, lifecycle rules, refactoring with moved blocks and CI workflows, with every command run on Terraform 1.16. (25 lessons)
System Design & Architecture
API Gateway and Service Mesh — Learn how API gateways and service meshes route, secure, protect and observe traffic: routing, canaries, rate limits, retries, circuit breakers, mTLS and operations, tested on a real gateway. (26 lessons)
Caching Strategies & CDN Design — Design caches that stay fast and correct: cache-aside, invalidation, stampedes, eviction, Redis, HTTP Cache-Control and ETags, and CDN keys and purging. (25 lessons)
Cost & Capacity Estimation — Learn back-of-the-envelope estimation: traffic, storage, bandwidth, servers, caches, queues and cloud cost, with worked examples and interview practice. (30 lessons)
High-Level & Low-Level Design Interview Problems — Worked high-level and object-oriented design problems, from parking lots and LRU caches to ride-hailing, payment ledgers and collaborative editors, with the trade-offs interviewers look for. (25 lessons)
Distributed Systems & Consensus (Raft / Paxos) — Learn distributed consensus from first principles: clocks, quorums, FLP, Paxos, Raft elections and logs, etcd, ZooKeeper, fencing and interview prep. (33 lessons)
Monolith vs Microservices — Compare monoliths, modular monoliths and microservices: trade-offs, service boundaries, data ownership, sagas, gateways, strangler-fig migration and teams. (25 lessons)
Rate Limiting, Circuit Breakers & Resilience Patterns — Keep services up when dependencies fail: timeouts, retries with jitter, circuit breakers, bulkheads, fallbacks, rate limiting and load shedding. (25 lessons)
Scalability, Availability & Reliability — Design systems that scale and stay up: SLOs and error budgets, load balancing, replication, sharding, availability maths, failure modes, DR and observability. (25 lessons)
System Design: Architecture, Scale and Trade-offs — Learn system design: estimate load, choose building blocks and weigh trade-offs for scalable, reliable systems. Built for engineers and interviews. (32 lessons)
Testing & Quality
Playwright & Cypress — Write reliable end-to-end browser tests with Playwright and Cypress: locators and assertions, authentication, network mocking, debugging flaky tests, visual and accessibility checks, and running at scale in CI. (25 lessons)
JUnit 5 & Mockito — Test Java code with JUnit 5 and Mockito: assertions, lifecycle, parameterized tests, mocks, verification, test design, Spring test slices and Testcontainers. (25 lessons)
Jest, Vitest & Testing Library — Write fast, trustworthy unit, integration and component tests for TypeScript frontends with Jest or Vitest, Mock Service Worker and Testing Library. (25 lessons)
Artificial Intelligence & Data
Agent Frameworks and MCP Basics — Understand the agent loop, tool calling, framework trade-offs and the Model Context Protocol, then build and secure your first MCP server. (25 lessons)
Agent Loops, Stop Conditions and Token Budgets — Learn how agent loops grow in cost, how to stop them safely, and how to budget tokens, time and money with guards, caching and graceful endings. (25 lessons)
Advanced Agent Workflows and Skills — Design reliable AI agent workflows: patterns, skills, subagents, hooks, context management, evals and safe automation. (25 lessons)
AI Agents and Tool Use — Learn how AI agents use tools: ReAct and planning, tool schemas, tool design, safety, evaluation and multi-agent patterns, with working Python examples. (25 lessons)
Estimating AI Automation ROI — Build AI business cases that survive contact with reality: measured baselines, task decomposition, review time, total cost of ownership, NPV and payback, sensitivity and Monte Carlo, adoption ramps and post-launch measurement, with every model run. (25 lessons)
Safe Rollout Plans for AI Features — Ship LLM features without surprises: launch bars, red-team gates, cost budgets, feature flags, staged ramps, shadow and canary tests, fallbacks, spend caps, rollback triggers and model upgrades, with every calculation run. (25 lessons)
AI Safety, Evaluation and Cost Control — Build LLM applications that are safe, measurable and affordable: safeguards, evaluation metrics, monitoring and cost control, with runnable Python examples. (25 lessons)
AI Strategy, Ethics and Governance — Plan AI adoption that delivers value responsibly: choosing use cases, building the business case, applying ethics, managing risk, setting governance and tracking regulation. (26 lessons)
Apache Airflow: Orchestrate Data Pipelines — Learn to schedule and monitor workflows with Apache Airflow: DAGs, TaskFlow, scheduling, XComs, branching, sensors, retries, idempotent design and deployment. (25 lessons)
Artificial Intelligence — The foundations of AI in one course: agents, search, A*, game playing, constraints, logic, probability, decisions, learning, reinforcement learning, language models and ethics, with every algorithm implemented and run in plain Python. (25 lessons)
Claude Code Skills & SKILL.md — Package your know-how as reusable skills: SKILL.md structure, descriptions that trigger, supporting scripts and references, testing, security review and team sharing, with validators and a script harness you can run. (26 lessons)
AI Coding-Agent Guardrails — Design layered guardrails for AI coding agents: permissions, sandboxes, secret and network controls, Git and CI gates, hooks, logging and incident response. (25 lessons)
Coding Agents & AI-Assisted Development — Understand how coding agents work and use them well: the agent loop, tools, edit formats, context, instruction files, test-driven workflows, parallel agents, verification, evaluation, cost and team practice, with a working mini agent you can run. (29 lessons)
Computer Vision — From pixels to production: image processing with OpenCV, keypoints, augmentation, pretrained classification, transfer learning, object detection, segmentation, evaluation metrics and robustness, with every example run on real sample images. (26 lessons)
Deep Learning & Neural Networks — Understand and build neural networks: neurons, backpropagation, PyTorch training loops, regularisation, CNNs, embeddings, attention, transformers and transfer learning, with every example run on CPU. (25 lessons)
Dify Workflow Basics — Build LLM apps visually with Dify: workflows and chatflows, prompts and variables, knowledge bases, routing, iteration, code nodes, structured extraction, API calls and streaming, with runnable Python for every testable piece. (25 lessons)
Embeddings & Vector Search — Understand how text becomes vectors and how to search them: similarity measures, learned embeddings, exact and approximate nearest neighbours, quantisation, hybrid search, evaluation and production, with every experiment run for real. (28 lessons)
Fine-tuning vs Prompting — Decide between prompting, retrieval and fine-tuning with evidence: how training changes a model, LoRA and other efficient methods, data quality, forgetting, evaluation and cost, with small real training experiments you can run. (27 lessons)
Hugging Face Transformers — Learn Hugging Face Transformers: pipelines, tokenizers, Auto models, text generation, datasets, fine-tuning with Trainer, LoRA, quantization and safe serving. (33 lessons)
LangChain / LlamaIndex — Build LLM applications with LangChain and LlamaIndex: prompts, runnables, parsers, tools, retrieval, indexes, query engines, agents and testing, with examples run offline using fake models. (31 lessons)
LangGraph Agents & Multi-Agent Systems — Build reliable agents as graphs: state, nodes, edges, loops, tools, memory, human approval, streaming, sub-graphs and multi-agent supervisors, with every example run for real offline. (29 lessons)
Claude API / OpenAI API Basics — Call LLM APIs confidently: requests and responses, messages, parameters, streaming, tool use, errors and retries, cost, security and testing, with the real Anthropic and OpenAI SDKs run against a local stand-in server. (27 lessons)
LLM Engineering Foundations — Turn LLM demos into dependable products: evaluation and statistics, prompt and model versioning, structured output, cost and latency engineering, reliability and observability, serving, governance and team practice, with every experiment run. (29 lessons)
LLM Observability (Langfuse / LangSmith) — Trace, debug, evaluate and cost-track LLM apps with Langfuse and LangSmith: spans, generations, feedback, datasets, prompts and production practice. (31 lessons)
LLM Application Security — Secure applications built on language models: prompt injection, unsafe output handling, excessive agency, data leaks, RAG access control, supply chain, abuse and cost attacks, testing and incident response, with attacks and defences you can run. (28 lessons)
Large Language Models — Understand how LLMs work from tokens and embeddings to attention, training, prompting, evaluation, safety and deployment, with small runnable models you can verify. (27 lessons)
Local LLMs with Ollama & llama.cpp — Run open-weight LLMs on your own machine with Ollama and llama.cpp: GGUF, quantization, APIs, RAG, tool calling, tuning and security. (30 lessons)
Machine Learning Basics — Learn machine learning by doing it: data splits, regression, classification, metrics, overfitting, cross-validation, ensembles and unsupervised learning, with every scikit-learn example run on real bundled datasets. (25 lessons)
MCP & Agent-to-Agent Protocols — Understand the protocols that connect AI agents to tools and to each other: MCP internals, building and securing servers, A2A agent cards and tasks, and how the two fit together, with a real server driven over JSON-RPC. (31 lessons)
MLOps — Take models from notebook to reliable production: experiment tracking, reproducibility, data validation, registries, CI gates, serving, shadow and canary releases, drift monitoring and retraining, with MLflow and scikit-learn examples run. (25 lessons)
Multimodal AI — Learn multimodal AI: images and audio as tensors, ViT encoders, CLIP, vision-language models, diffusion, multimodal RAG, cost, evaluation and safety. (33 lessons)
AI Automation with n8n — Build, secure and run AI-powered workflows in n8n: triggers, data handling, the AI Agent node, tools, RAG, error handling, guardrails and self-hosting. (25 lessons)
NumPy / Pandas / scikit-learn — The core Python data stack, hands on: fast arrays with NumPy, data wrangling with pandas, and honest machine learning with scikit-learn, with every example run on NumPy 2.5, pandas 3.0 and scikit-learn 1.9. (25 lessons)
OpenAI Agent Builder Workflows — Design agent workflows on a visual canvas and in code: nodes, state, routing, loops, handoffs, approvals, guardrails, evals, versioning and cost, with runnable Agents SDK and Python snippets. (26 lessons)
Prompt & Context Engineering — Go beyond wording: decide what the model sees, how much, in what order and in what structure. Token budgets, retrieval packing, compression, memory, caching, structured output and untrusted content, with every snippet run. (25 lessons)
Prompt Engineering — Write prompts that work reliably: structure, examples, reasoning, structured output, context limits, safety and evaluation, with small runnable harnesses to test your prompts. (29 lessons)
Prompt Quality Scoring — Measure prompts instead of guessing: prompt linting, format checks, weighted rubrics, calibrated LLM judges, bias checks, pairwise ratings, significance tests, cost-quality frontiers and regression gates, with every calculation run. (25 lessons)
PyTorch — Learn PyTorch from tensors and autograd to nn.Module models, training loops, data pipelines, GPUs, mixed precision, saving and deployment. (33 lessons)
Retrieval-Augmented Generation (RAG) — Build question-answering systems grounded in your own documents: chunking, embeddings, keyword and hybrid search, reranking, prompts, citations, evaluation and production concerns, with small runnable examples. (27 lessons)
RAG Retrieval & Evaluation — Measure a RAG system instead of eyeballing it: evaluation sets, retrieval metrics, statistics, retriever and chunking experiments, answer faithfulness, calibrated LLM judges and release gates, with every snippet run. (25 lessons)
Safe Autonomous Code Fixing — Let AI fix bugs without breaking trust: reproduce with failing tests, localise with traces and git bisect, keep patches minimal, verify in isolation, detect test tampering and secrets, review and revert safely, with every step run in Python and real git. (25 lessons)
Apache Spark: Big Data Processing with DataFrames — Learn Apache Spark with PySpark: architecture, DataFrames, SQL, joins, windows, lazy execution, shuffles, performance tuning, streaming and production deployment. (25 lessons)
1Password and Secrets Hygiene for Developers — Learn to store, share, use and rotate passwords, API keys and tokens safely with 1Password, the op CLI and good Git habits. (24 lessons)
Career & Interview Prep
Behavioural Interview Prep — Prepare for behavioural interviews as a software engineer: how answers are assessed, the STAR method, a reusable story bank, the core question types, level-specific expectations and practical delivery. (25 lessons)
DSA Interview Patterns — Recognise the twenty or so patterns behind most coding interview questions and explain your solution clearly, with every solution written in Python and run against test cases. (26 lessons)
Resume & GitHub Portfolio — Build an honest, focused software engineering resume and a GitHub portfolio that shows real skill: strong bullets, tailoring, readable formatting, project READMEs, code quality signals and a final checklist. (25 lessons)
System Design Interview Prep — Practise structured, defensible design conversations: a repeatable interview framework, back-of-envelope maths, the core building blocks and classic case studies, with the key numbers computed by small Python simulations you can run. (25 lessons)