Explore Courses

Advanced

Production Elixir Toolkit: Oban, Broadway and the Modern BEAM Stack

 A professional, project-based course for experienced Elixir developers who want to design reliable production systems rather than merely install popular packages. Across 20 substantial lessons you will work with Mix, runtime configuration, Req and Finch, OTP task supervision, Oban, transactional outbox patterns, GenStage, Broadway, Flow, Phoenix PubSub and Presence, Cachex, Swoosh, Telemetry, OpenTelemetry, ExUnit, Mox, StreamData, Credo, Dialyxir, Sobelow, Benchee, Recon, libcluster, Horde, releases and Bandit. ## What you will build The capstone is an event-processing platform with a synchronous Phoenix/Ecto core, durable Oban workflows, Broadway ingestion, bounded outbound HTTP, caching, notifications, observability, quality gates and an operable release. ## Audience and prerequisites This is an intermediate-to-advanced course. You should already understand Elixir syntax, pattern matching, modules, processes, supervision basics, Mix and Ecto fundamentals. PostgreSQL and Docker experience are helpful. ## Course method Each lesson includes two custom diagrams, detailed production theory, a compact implementation example, a failure-injection experiment, a practical assignment, an operational checklist and five self-check questions. Estimated study time is 60–90 minutes per lesson plus project work. > Package versions are a July 2026 learning baseline. Always check the official documentation and changelog before upgrading a real application.

elixir otp

Intermediate

Access & Identity Technologies for Web Developers

 A practical course about authentication, authorization and identity federation. Learn RBAC, ABAC and ReBAC as application policy models; understand OAuth 2.0, OpenID Connect and SAML 2.0 protocol flows; and implement phishing-resistant authentication with WebAuthn and passkeys. Examples use HTTP, JSON, XML, SQL, JavaScript and Ruby on Rails, with technical diagrams, security checklists and a final multi-tenant SaaS capstone.

security authentication

Intermediate

AI Loop Development: Building Reliable Agentic Systems

A practical, engineering-first course on **AI loop development** — the discipline of building systems where a language model repeatedly plans, acts through tools, observes results, and decides what to do next. You will learn the anatomy of the agentic loop, tool-calling mechanics, context and state management, guardrails and error recovery, evaluation and observability, multi-agent orchestration, and what it takes to run loops in production. Every lesson includes worked code examples, a checklist, and a self-check quiz. The final lesson is a glossary of the field's core terminology. **Audience:** developers who have called an LLM API at least once and want to move from single prompts to autonomous, multi-step systems. Examples use Python-style pseudocode that maps directly onto any modern LLM SDK.

ai agents

Intermediate

System Design for Web Developers

A practical system design course for experienced web developers (mid-level+). You already ship features; this course teaches you to reason about what happens when your app meets real traffic: scaling, load balancing, caching, database replication and sharding, consistency trade-offs, message queues, API styles, service decomposition, CDNs, and production reliability. The capstone walks through a full interview-style design of a URL shortener, from capacity estimation to failure modes. Every lesson pairs theory with concrete numbers, code-level examples, architecture diagrams, a checklist, and a self-check quiz.

system-design architecture

Beginner

Thai Cuisine: A Complete 14-Day Course

A complete fourteen-day course in Thai cooking, moving from essential ingredients and flavor balance to curries, soups, noodles, salads, rice dishes, sauces, and desserts. The lessons explain not only recipes but the logic of Thai cooking: ingredient order, aromatic foundations, texture, and final flavor adjustment. Designed for a home kitchen, the course includes practical substitutions for ingredients that may be difficult to find. By the end, learners can plan a Thai menu, adjust heat levels, and prepare a range of dishes while preserving their characteristic balance of flavors.

thai cuisine cooking

Intermediate

Cloud, DevOps, and Kubernetes in Practice

A practical course on cloud, DevOps, and Kubernetes — from culture and containers to production operation of clusters. Aimed at a developer or engineer who wants to confidently deploy and operate services in a cloud-native environment: to understand containers, orchestration, configuration, storage, networking, observability, CI/CD, GitOps, infrastructure as code, and security. The course is built around the **declarative model**: you describe the desired state of the system, and the platform brings reality to it and holds it there. This is the through-line of all modern DevOps — from Kubernetes manifests to Terraform and GitOps. Once you master it, you stop "clicking buttons by hand" and start managing infrastructure as code: versioned, reproducible, reviewable. Topics build up: DevOps and cloud foundations, containers and Docker, Kubernetes architecture, workloads (Pod/Deployment/StatefulSet), networking and Service/Ingress, configuration and secrets, storage and state, packaging (Helm/Kustomize), observability, CI/CD and GitOps, infrastructure as code and security, production and scaling. Examples are given as of mid-2026 (Kubernetes 1.3x, ArgoCD/Flux, OpenTelemetry) — the principles matter more than the specific versions, which update constantly. Each lesson contains theory, examples (YAML manifests and `kubectl`/CLI commands), a checklist of practical tasks, and a quiz. It's convenient to practice on a local cluster (kind/minikube/k3s) or in a managed cloud. The main principle: infrastructure is code. Anything done "by hand" and not written down is technical debt and a source of drift between environments.

devops kubernetes

Intermediate

Data Science in Practice

A practical data science course — from the workflow and data preparation to machine learning and putting results into the real world. Aimed at a developer or analyst who wants to learn to extract value from data: to load and clean it, explore it, visualize it, build and evaluate models, and understand where data science ends and engineering begins. Basic Python is enough (the collection has a separate Python course); the whole stack is Python. The main principle of the course: **80% of a data scientist's work is the data, not the models.** Beautiful algorithms are useless on dirty data; "garbage in, garbage out." So the emphasis is on preparation, cleaning, exploration, and honest evaluation. The second through-line is **skepticism and rigor**: correlation isn't causation, a good metric on the training set means nothing, and a model that "works" in a notebook can fail in production because of data leakage. Data science is the discipline of drawing careful conclusions from noisy reality. Topics build up: the workflow and tooling, NumPy, pandas, data cleaning, transformation and aggregation, exploratory analysis and visualization, statistics, an introduction to machine learning, scikit-learn, model evaluation and working with features, and putting things into production. The 2026 stack: the core (NumPy, pandas, matplotlib/seaborn, scikit-learn, Jupyter) plus modern tools (Polars, DuckDB) — but the principles matter more than the specific libraries. Each lesson contains theory, code examples (Python), a checklist of practical tasks, and a quiz. It's convenient to practice in Jupyter/a notebook on real datasets. This course is the foundation of applied analysis; for the depth of machine learning proper and modern AI, see the ML/AI course, and for LLM applications, see the LLM course.

data-science python

Intermediate

ML, AI, and Agentic Development: From Foundations to Tools

A course about **how machine learning, deep learning, and modern AI actually work** — and how to build agentic systems on that foundation. Aimed at a developer who wants not just to "call an API" but to understand the engine under the hood: how models learn, what neural networks and transformers are, where large language models came from, and how to assemble an agent from a model that acts in the world through tools. The course deliberately **complements** two others in the collection. The Data Science course provides applied classical ML (pandas, scikit-learn, evaluation) — here we go deeper into the *principles*: optimization, neural networks, deep learning. The LLM course teaches you to *build applications* on top of ready-made models (prompting, RAG, API) — here we explain *why* those models work and rise to the engineering of agents as a discipline. Together, the three courses give the full picture: apply, understand, build. Two parts. **Foundation (lessons 1–7)**: the map of AI/ML/DL, how models learn (optimization), learning paradigms, neural networks, deep learning architectures, transformers and LLMs, foundation models and generative AI. **Agents and engineering (lessons 8–12)**: what an agent is, tools and the MCP protocol, patterns and frameworks for agentic systems, evaluation and safety, production. The tooling landscape is given as of mid-2026 (MCP, LangGraph, agent orchestration) — but the principles matter more than the specific libraries, which change monthly. Each lesson contains theory, examples (diagrams, pseudocode, Python), a checklist, and a quiz. The through-line: modern AI isn't magic but an understandable engineering tower of ideas, each of which can be mastered. Understanding the foundation distinguishes someone who deliberately builds reliable systems from someone who copies other people's code and hopes it works.

machine-learning ai

Intermediate

LLM: From Basics to Practical Use

A practical course on large language models (LLMs) — from how they're built to assembling real applications. Aimed at a developer who wants not to "play with a chatbot" but to deliberately embed LLMs into products: to understand what a model can and fundamentally cannot do, write reliable prompts, work with APIs, build embedding-based search and RAG, connect tools and agents, evaluate quality, and ship it all to production. The course is not about the mathematics of transformers or about training models from scratch — it's about engineering on top of ready-made models. Being able to program is enough; the examples are in Python (the lingua franca of the LLM ecosystem), but all communication with models goes over HTTP, so the approach applies on any stack. The key principle running through the whole course: **LLMs are non-deterministic and don't know the truth — they predict plausible text.** So engineering around them isn't "asking the model" but building a system: give it the right context, constrain the format, check the output, measure quality, and defend against failures and abuse. The model is a powerful but unreliable component; the engineer's job is to make the system reliable around an unreliable component. Pace 1–2 hours a day. Each lesson contains theory, code examples, a checklist of practical tasks, and a quiz. The model landscape changes monthly, so specific names and prices are given as an illustration as of mid-2026 — the principles of choosing matter more than the current benchmark champion.

llm ai

Intermediate

Python in Practice

A practical Python course for an experienced developer (mid-level+) who wants to confidently write server-side code, scripts, CLI tools, and work with data. Pace: 1-2 hours a day, ~3 weeks. Python is a dynamic, expressive language with a "explicit is better than implicit" philosophy and one of the richest ecosystems around. Key features: significant whitespace, comprehensions, generators and iterators, context managers, type hints, async/await, and one of the widest library ecosystems in the world. Each lesson includes theory with visual diagrams, code examples, a checklist, and a quiz.

python backend

Advanced

Phoenix: Production SaaS on Elixir

A practical Phoenix course for building secure, modern SaaS services. A continuation of the Elixir course — solid command of the language is assumed (immutability, pattern matching, processes, OTP, GenServer/Supervisor). Targeted at Phoenix 1.8 (scopes, magic links, updated security headers, LiveView 1.1). The course is built around what you actually need to ship a SaaS to production: layered architecture (thin web, thick contexts), Ecto (schemas, changesets, queries, transactions), authentication and authorization with scopes, multi-tenancy, LiveView for interactive UI, full testing (ExUnit, LiveViewTest, Mox, factories, E2E), background jobs with Oban, security (OWASP, Sobelow, MixAudit, CSP, encryption), and production operations (releases, config, observability, deployment). As in the series' language courses, parallels are drawn for a developer from the Rails world: Phoenix ≈ Rails (but functional and explicit), Ecto ≈ ActiveRecord (but without magic, changesets explicit), contexts ≈ service objects, LiveView ≈ Hotwire/Turbo (but on the server, over WebSocket), Oban ≈ Sidekiq (but in PostgreSQL, transactional), ExUnit ≈ RSpec/Minitest. Pace 1–2 hours a day, roughly 3–4 weeks. Each lesson contains theory, Phoenix 1.8 code examples, a checklist of practical tasks, and a quiz. The main 1.8 principle: security by default — scopes make data isolation the default, not something you have to remember to add later.

phoenix elixir

Intermediate

Ecto: From Zero to Advanced

A complete Ecto course — from your first query to advanced techniques. Ecto is not an ORM but a tandem of a data mapper and a query language: explicit, composable, without magic. Knowledge of Elixir is assumed (pattern matching, pipe, structs). Ecto is used in Phoenix, but it's a standalone library and works without it — the course accounts for that. Examples are on PostgreSQL (the ecosystem's main database), but most applies to MySQL/SQLite. The course covers Ecto's four pillars — Repo (database access), Schema (table mapping), Changeset (data validation and transformation), Query (a composable query DSL) — and moves from basics to advanced: associations and the fight against N+1, complex queries (joins, subqueries, window functions, CTEs, dynamic queries), transactions via Ecto.Multi, embedded and schemaless changesets, upserts and bulk operations, multi-tenancy via prefixes, custom types, plus testing, performance, and safe migrations in production. For a developer from Rails, parallels are drawn: Ecto ≈ ActiveRecord, but without magic and with explicit changesets; `Repo` ≈ what's spread across models in AR; migrations are similar, but fully reversible. The key difference from AR — Ecto separates data (schema), its modification (changeset), and access (Repo), rather than mixing everything into an "active record." Pace 1–2 hours a day. Each lesson contains theory, code examples, a checklist of tasks, and a quiz. The main principle: Ecto makes database work explicit — you always see what SQL will run, which fields are accepted from input, and when a database access happens.

ecto elixir

Intermediate

Elixir in Practice

A practical Elixir course for an experienced developer (mid-level+) who wants to master a functional language on the BEAM VM with fault-tolerant concurrency. Pace: 1–2 hours a day, ~3 weeks. Elixir is a functional language on the BEAM virtual machine (the Erlang VM), built for telecommunications. Main advantages: millions of lightweight processes with isolated GC, hot code upgrades, the "let it crash" philosophy, and OTP — fault-tolerance patterns proven over decades. Elixir adds to BEAM's power a modern syntax, a macro system, and an ecosystem (Phoenix, Ecto, LiveView). Topics build up: Mix and syntax basics, pattern matching and immutability, collections, functions and the pipe operator, Enum/Stream and error handling, processes and the actor model, OTP (GenServer, Supervisor), protocols and tests, Phoenix and the ecosystem. Each lesson contains theory with visual diagrams, code examples, a checklist, and a quiz. The main principle: Elixir's strength isn't its syntax but immutability, processes, and OTP.

elixir beam

Intermediate

Rust in Practice

A practical Rust course for an experienced developer (mid-level+) who wants to master a systems language with memory-safety guarantees without a garbage collector. Pace: 1–2 hours a day, ~3 weeks. Rust occupies the C/C++ niche but offers compile-time safety: the ownership system and borrow checker eliminate use-after-free, data races, and memory leaks before the program even runs. The philosophy: zero-cost abstractions — high-level code compiles into code as efficient as hand-written low-level. Topics build up: Cargo and syntax basics, ownership and borrowing, structs and enums (algebraic types), error handling (Result/Option), collections and a mini-project, traits and generics, iterators and modules, concurrency and a final project, async and the ecosystem. Each lesson contains theory with visual diagrams, code examples, a checklist, and a quiz. The main principle: the compiler is your ally, not your adversary. Every compile error is a bug that won't exist in production.

rust systems

Intermediate

Go in Practice

A practical Go course for an experienced developer (mid-level+) who wants to confidently write server code, CLI tools, and concurrent services in Go. Pace: 1–2 hours a day, ~3 weeks. Go was designed at Google for large server systems: simplicity, readability, fast compilation into static binaries, powerful concurrency (goroutines and channels). The language is deliberately minimal — fewer features, but each one thought through; one obvious way to do things. This makes Go ideal for backends, microservices, and infrastructure tools (Docker, Kubernetes, Terraform are written in Go). Topics build up: the toolchain and syntax basics, the type system (pointers, structs, slices, maps), methods and interfaces (duck typing), error handling as values, a mini-project, concurrency (goroutines, channels, select), the standard library and HTTP servers, testing and a final project, the ecosystem and next steps. Each lesson contains theory with visual diagrams (PNG diagrams and mermaid), code examples, a checklist of practical tasks, and a quiz. Go's main principle: simplicity over cleverness — if code can't be understood in 30 seconds, rewrite it simpler.

go golang

Intermediate

TypeScript in Practice

A practical TypeScript course — from "why types at all" to the advanced type system and production setup. Aimed at a developer who already writes JavaScript and wants to add static typing: catch errors before running, get autocompletion and refactoring, document interfaces with types. Knowledge of JavaScript is a prerequisite: TypeScript is a superset of JS, meaning all JS stays valid, with a type system added on top. The course isn't about relearning from scratch but about how to think in types. The main idea: types aren't bureaucracy for the compiler but a design tool. A well-described type makes invalid states unrepresentable, turns a whole class of bugs into editor errors, and serves as living documentation. TypeScript is **erased at compile time** — at runtime it's ordinary JavaScript, and types exist only for checking. Understanding this boundary (compile-time checking vs runtime behavior) is the key to the whole course. Topics build up: basic types and type inference, typing functions, interfaces and object types, union types and narrowing, generics, classes and modules, utility and advanced types (mapped, conditional, template literal), `tsconfig` configuration and tooling, and the ecosystem. Lessons 9–10 cover real project setup and where to go next. Each lesson contains theory, code examples, a checklist of practical tasks, and a quiz. Examples are checked by the `tsc` compiler. It's most convenient to work in an editor with TS support (VS Code) — half of TypeScript's value shows up precisely in the hints and errors while you write the code.

typescript javascript

Intermediate

JavaScript in Practice

A practical JavaScript course for an experienced developer (mid-level+) who wants to confidently write modern JS for the frontend, the backend (Node.js), and understand the async model. Pace: 1-2 hours a day, ~3 weeks. JavaScript is the only language that runs both in the browser and on the server. Its defining trait is single-threadedness + the event loop + asynchrony. Key features: prototypal inheritance, closures, arrow functions, destructuring, async/await, and a vast ecosystem (npm). Each lesson includes theory with visual diagrams, code examples, a checklist, and a quiz.

javascript frontend