Cloud Contraptions delivers around 150 days of training each year to organizations around the world.
Cloud Contraptions offers a variety of courses on programmings tools, languages, and frameworks. Each class is taught live with an expert instructor online or on-site at your location. We specialize in customized training solutions to meet the unique needs of your organization.
We teach classes in-person and online. We are able to teach online classes with Zoom, Microsoft Teams, Cisco WebEx, GotoTraining, and Google Meet. For online classes, we are able to accomodate non-traditional training schedules such as half-day classes or classes that meet only a few hours a day over multiple days or weeks.
Classes sold directly by Cloud Contraptions can be recorded with recordings made available after each day of class once the meeting software finishes processing it. Classes sold through third-party training marketplaces may have different policies on recording availability.
Please review our courses below organized by topic and technology. The outlines you are only a starting point. We can customize any course to meet your specific needs. Contact us to discuss your training requirements and get a quote.
Reframes prompt engineering around context windows, system prompts, tool definitions, and structured outputs for professional software development workflows.
Model-agnostic foundations covering capabilities, tradeoffs, pricing, latency, and when to reach for which frontier model in real engineering workflows.
Consolidates Chat, Edits, Agents, Spaces, MCP, the Copilot CLI, and Next Edit Suggestions into one current course covering everything developers and teams need from GitHub Copilot today.
Composer 2.0 (Cursor's Kimi K2.5-based in-house model), Background and Cloud Agents, rules files, and project-level context management in Cursor 3.0 for professional development teams.
Terminal-driven agentic development with Claude Code: subagents, hooks, skills, plugins, slash commands, CLAUDE.md configuration, and real-world workflows.
A 1-day decision-oriented survey of the leading coding agents — Claude Code, OpenAI Codex, Aider, and Devin — that funnels into the dedicated deep-dive courses for the chosen tool.
Using AI agents in CI to review, refactor, and ship code — covering pull request automation, agentic code review workflows, and CI integration patterns.
Spec-driven development with GitHub Spec Kit: the specify → plan → tasks → implement workflow, writing effective specifications, and integrating with Copilot, Claude Code, Cursor, Windsurf, and Gemini CLI.
OpenAI Codex as a multi-surface platform: the open-source CLI, IDE extensions for VS Code and JetBrains, cloud agents, Skills, Automations, and the GPT-5.x Codex model family.
Delegate real engineering work to GitHub Copilot agents — in the IDE, in the terminal, and on github.com — covering agent mode, the Copilot CLI, the cloud coding agent, issue-to-PR workflows, and agentic code review.
Delegate real engineering work to Claude Code agents — in the terminal, in the IDE, and on github.com — covering plan mode, subagents, the cloud agent, issue-to-PR workflows, and agentic code review.
Delegate real engineering work to Cursor agents — in the IDE, in the terminal, and in the cloud — covering agent mode, plan mode, the Cursor CLI, background agents, Bugbot review, and issue-to-PR workflows.
Delegate real engineering work to Windsurf agents — Cascade in the editor and Devin cloud agents in the Agent Command Center — covering planning mode, memories and rules, MCP, issue-to-PR workflows, and agentic code review.
Hands-on coverage of Aider's features: chat modes and architect mode, git-first workflows, repo maps, auto-lint and auto-test loops, conventions files, scripting, and running fully local with open-weight models.
A 5-day intensive for professional Python developers: prompting and context engineering, IDE assistants, agentic coding with your choice of AI tools (Claude Code, GitHub Copilot, Codex, Cursor, Windsurf, Gemini CLI, and others), AI-driven testing, and secure, governed adoption — all with Python-specific labs.
A 5-day intensive for professional Rust developers: prompting and context engineering, IDE assistants, agentic coding with your choice of AI tools (Claude Code, GitHub Copilot, Codex, Cursor, Windsurf, Gemini CLI, and others), AI-driven testing, and secure, governed adoption — all with Rust-specific labs.
A 5-day intensive for professional JavaScript and TypeScript developers: prompting and context engineering, IDE assistants, agentic coding with your choice of AI tools (Claude Code, GitHub Copilot, Codex, Cursor, Windsurf, Gemini CLI, and others), AI-driven testing, and secure, governed adoption — all with JS/TS-specific labs.
A 5-day intensive for professional C# developers: prompting and context engineering, IDE assistants, agentic coding with your choice of AI tools (Claude Code, GitHub Copilot, Codex, Cursor, Windsurf, Gemini CLI, and others), AI-driven testing, and secure, governed adoption — all with .NET-specific labs.
Comprehensive training on secure coding principles, vulnerability assessment, and integrating security into the software development lifecycle through DevSecOps practices.
Build production-grade CI/CD pipelines with GitHub Actions: workflow syntax and triggers, matrix builds, caching, reusable workflows, environments and deployment protection, OIDC cloud authentication without long-lived keys, supply-chain security hardening, monorepo and release strategies, and AI agents in CI.
Instrument, collect, and analyze traces, metrics, and logs with OpenTelemetry: auto and manual instrumentation in Python, .NET, and Node.js, context propagation, the OTel Collector, sampling, semantic conventions, Grafana/Prometheus/Jaeger/Tempo backends, SLOs, dashboards, cost control, and observability for LLM applications.
Build fast, reliable, and secure applications on PostgreSQL 18: Docker setup, SQL and schema design, JSONB, performance tuning, PL/pgSQL, security with OAuth, async SQLAlchemy 2.0 with asyncpg, pandas with ADBC, and pgvector similarity search.
A standards-first introduction to SQL for developers and analysts, taught on PostgreSQL 18: the relational model, SELECT, filtering and sorting, joins taught visually, aggregation, subqueries and CTEs, window functions, data modification, transactions, constraints, NULL semantics, indexing intuition, execution plans, and reviewing AI-generated SQL.
A 5-day foundation course for software engineers new to AWS: cloud concepts and global infrastructure, IAM and security best practices, core compute, storage, database, and networking services, monitoring, cost management, infrastructure as code, and an introduction to AWS AI/ML services.
A 5-day course for software engineers and solution architects covering the AWS Well-Architected Framework, resilient compute and serverless patterns, storage and data architecture, advanced networking, security, cost optimization, infrastructure as code, CI/CD, and AI-powered application design.
A 5-day introduction to Microsoft Azure for software engineers: core cloud concepts, compute, storage, networking, identity with Microsoft Entra ID, security, monitoring, cost management, Bicep infrastructure as code, and Azure AI services.
A 5-day course on designing enterprise-grade Azure infrastructure with the Well-Architected Framework: governance and landing zones, compute, containers, data and storage, networking, zero-trust security, business continuity, FinOps, Bicep, and AI workload design.
A 5-day course on how cloud computing reshapes enterprise architecture: cloud models and provider ecosystems, adoption strategy with the 7 Rs migration framework, security and governance, the FinOps Framework's Cloud+ approach, organizational transformation, and emerging trends.
A 2-day course for developers who use Git daily but want to use it well: the Git object model, branching strategies, pull request workflows and code review etiquette, history surgery with interactive rebase and bisect, reflog recovery, GitHub collaboration features like CODEOWNERS and rulesets, and working alongside AI coding agents.
A 2-day course for developers who want real command-line fluency: shell fundamentals, files, permissions, and processes, pipes and redirection, text tooling with grep, sed, awk, and jq, robust Bash scripting with proper error handling, ShellCheck, SSH, tmux, and writing the automation scripts that make daily development faster.
A 2-day course on designing APIs that last: resource modeling and HTTP semantics, pagination and versioning patterns, error design with RFC 9457 Problem Details, contract-first workflows with OpenAPI, OAuth2/OIDC and rate limiting, webhooks and AsyncAPI, when to choose GraphQL or gRPC, API governance, and designing APIs for AI agents and MCP consumption.
A 3-day course for professional Python developers: SOLID principles applied honestly, the Gang of Four patterns that still matter in modern Python, Pythonic alternatives using first-class functions, protocols, decorators, and modules, refactoring toward patterns from real code smells, avoiding overengineering, and reviewing pattern use in AI-generated code.
A 3-day course for professional C# developers: SOLID principles applied honestly, the Gang of Four patterns that still matter on .NET 10, modern C# alternatives using delegates, records, pattern matching, and LINQ, the built-in dependency injection container, refactoring toward patterns from real code smells, avoiding overengineering, and reviewing pattern use in AI-generated code.
A 3-day course for professional TypeScript developers: SOLID principles applied honestly, the Gang of Four patterns that still matter in modern TypeScript, structural typing and discriminated unions as alternatives to class hierarchies, generics and conditional types in pattern design, functional composition, dependency injection in the TS ecosystem, patterns in React and Node contexts, and reviewing pattern use in AI-generated code.
A 2-day course on building a reliable end-to-end test suite with Playwright: locators and web-first assertions, fixtures and test isolation, network mocking, authentication state reuse, parallelism and sharding, trace viewer debugging, visual comparisons, CI integration, flake reduction, API testing, and AI-assisted test generation with Playwright Agents.
Programming Languages
Rust Essentials (21 hours delivered over 3-5 days, online or on-site)
A hands-on, beginner-friendly introduction to modern Rust on the 2024 edition: ownership and borrowing, expressive types, idiomatic error handling, and an honest workflow for using AI assistants safely with the Rust compiler as a guardrail.
Mastering Rust (35 hours delivered over 5-10 days, online or on-site)
An in-depth Rust 2024-edition deep dive covering ownership, traits and generics, async with async fn in traits and async closures, advanced concurrency, unsafe and FFI, macros, and an AI-augmented workflow that uses Claude Code, Cursor, and Copilot the way senior Rust engineers actually use them.
A structured pathway from Python to production Rust on the 2024 edition: ownership, traits, async, and PyO3 extensions, taught with Python contrasts throughout and a realistic AI-augmented workflow using Claude Code, Cursor, and GitHub Copilot.
A 3-day fast-track from Python to working Rust on the 2024 edition: ownership, types, traits, iterators, async, and an AI-assisted workflow that makes Python developers productive in Rust quickly.
A structured pathway from JavaScript and TypeScript to production Rust on the 2024 edition: ownership instead of GC, traits instead of interfaces and duck typing, async on Tokio, and full-stack Rust with Actix-web 4 and Leptos — taught with AI-assisted workflows using Claude Code, Cursor, and GitHub Copilot.
A structured pathway from C# and .NET to production Rust on the 2024 edition: ownership instead of GC, traits instead of interfaces, async on Tokio instead of Task, and an AI-augmented workflow using Claude Code, Cursor, and GitHub Copilot.
Rust Refresher (14 hours delivered over 2-4 days, online or on-site)
A concise, hands-on refresher on the Rust 2024 edition: ownership, idiomatic data modeling, pattern matching, generics, and a fast tour of async closures, async fn in traits, let-chains, and an AI-augmented Rust workflow.
A focused course for working Rust developers on the borrow checker, lifetimes, smart pointers, interior mutability, and self-referential structures — with practical guidance for using AI assistants on memory-management problems without bypassing Rust's safety guarantees.
Master Rust's concurrency and parallelism on the 2024 edition: Rayon, Crossbeam, atomics, async fn in traits, async closures, FFI, and procedural macros — with an AI-assisted workflow that uses Claude Code, Cursor, and Copilot to ship safer parallel code.
Learn modern Python 3.14: virtual environments with uv, formatting and linting with ruff, t-strings (PEP 750), pattern matching, type hints, and the standard tooling that every Python team uses in 2026.
Level up to production Python: development environments with uv, advanced language features, the free-threaded build (PEP 703/779) on Python 3.14, threading vs. asyncio vs. multiprocessing, and a clear-eyed treatment of the GIL.
Production Python OOP: classes, dataclasses, protocols, SOLID, and design patterns — taught alongside an AI-assisted workflow with Claude Code, Cursor, and GitHub Copilot. Covers Python 3.14 features (PEP 695 generics, PEP 750 t-strings) and free-threaded considerations.
Master Python's stdlib `unittest` framework on Python 3.14: TestCase, fixtures, mocks (`unittest.mock`), test organization, coverage, and a comparison with pytest. Practical for teams whose policy mandates the stdlib library.
Master pytest 9.x on Python 3.14: fixtures, parametrize, monkeypatching, hypothesis, mocks, coverage, and pytest plugins. Covers TDD discipline, AI-assisted test writing, and CI integration.
Take CPU-bound Python hot paths and rewrite them in Rust — with PyO3 0.28+, Maturin, GIL-free parallelism, and an AI-assisted workflow that uses Claude Code, Cursor, and Copilot to ship native Python wheels in days, not weeks.
A 1-day course for experienced Python developers on accelerating CPU-bound Python code with native code: Numba JIT compilation, wrapping C libraries with CFFI, modern C++ bindings with PyBind11 and nanobind, direct C extensions with the Python C API, and the GIL and officially supported free-threaded Python (PEP 703 / PEP 779).
A 2-day course teaching Cython 3 as a serious tool for high-performance Python: compiling pure Python, static typing, typed memory views and NumPy 2.x interop, wrapping C libraries, parallel programming with nogil and prange, extension types and fused types, distribution to PyPI and Conda including free-threaded wheels, and debugging and profiling Cython code.
A 1-day course for experienced Python developers on accelerating CPU-bound Python with Zig: extension modules via the CPython C API and @cImport, the Ziggy Pydust toolkit, buffer protocol and NumPy interop, cross-compiling wheels with zig cc and cibuildwheel, honest benchmarking against Cython, Rust, and C++, and free-threaded Python considerations.
The C Programming for Python Developers course is designed for students looking to learn C programming and integrate custom C libraries into their Python programs, with a focus on teaching C essentials, and prior knowledge of Python is optional but mentioned in later parts of the course.
Master modern JavaScript on the latest ECMAScript standards: ES2025's iterator helpers, Set methods (union/intersection/difference), Promise.try, RegExp.escape, and JSON modules, plus the ES2026 using/Symbol.dispose pattern, DOM, modules, async/await, and modern tooling (Vite, ESLint 9, Prettier).
Advanced modern JavaScript: ES2025 features (iterator helpers, Set methods), ES2026's using/Symbol.dispose and Temporal API, decorators (Stage 3), WeakRef/FinalizationRegistry, async iterators, structured clone, modules, and meta-programming.
Master TypeScript 6.x on the ES2025 spec: structural types, generics with `const` type parameters, satisfies, the `using` declaration, decorators (Stage 3), narrowing, conditional and template-literal types, modules, and Vite/esbuild-era tooling.
A 3-day deep dive into TypeScript's type system for experienced TypeScript developers: generics mastery, conditional and mapped types, template literal types, declaration files and library publishing, tsconfig and project references, compiler performance diagnostics, the TypeScript 7 native compiler beta, and type-level testing.
A hands-on 3-day course on building production Node.js backends with TypeScript: modern ESM project setup, Fastify 5 (with Express 5 comparison), Zod 4 validation, layered architecture, Drizzle database access, JWT/OIDC auth, end-to-end type safety with tRPC and OpenAPI, pino logging, Vitest testing, and Docker deployment.
A practical 2-day course on migrating JavaScript codebases to TypeScript: migration strategy and business case, incremental adoption with allowJs/checkJs and JSDoc, strictness ratcheting, typing legacy patterns, third-party types, monorepo migration with project references, codemods, AI-agent-assisted conversion, and keeping CI green throughout.
A 2-day translation-focused course for professional C# developers learning TypeScript: structural vs nominal typing, generics differences, LINQ to array methods, async/await and the event loop, nullability, unions and literal types, ESM modules, the npm ecosystem, tooling mapping from MSBuild and xUnit, and what replaces reflection in an erased type system.
Learn Zig 0.16: explicit allocators, comptime, error sets, the new std.Io async I/O system (async/await reintroduced), build system 2.0, and C interop. A compiled, low-level systems language with no hidden control flow.
Advanced Zig (21 hours delivered over 3 days, online or on-site)
A 3-day deep dive into Zig 0.16 for working Zig programmers: comptime metaprogramming, allocator design, the redesigned std.Io async I/O interface with io_uring and Grand Central Dispatch backends, error handling at scale, data-oriented design, SIMD with @Vector, and testing, fuzzing, and profiling.
A 2-day translation course for experienced C and C++ developers: map pointers, RAII, errno, NULL, macros, templates, and malloc onto Zig's slices, defer, error unions, optionals, comptime, and allocators — plus @cImport, translate-c, and incrementally mixing Zig into an existing C/C++ codebase.
A 2-day course on the Zig toolchain as build infrastructure: zig cc as a zero-dependency drop-in C/C++ cross-compiler, target triples and glibc/musl selection, build.zig anatomy, build.zig.zon package management, building existing C/C++ projects, caching, CI integration, and comparison with CMake and Make. No Zig language experience required.
A 5-day intensive on end-to-end LLM application development in Python: model APIs, prompt pipelines, structured outputs with Pydantic, tool calling, streaming FastAPI services, RAG essentials, evals, observability, and production deployment.
A 5-day intensive on building production AI agents in Python: agent loops, LangGraph and Pydantic AI, building MCP servers and clients, multi-agent orchestration, agent evals, security guardrails, and running open-weight models locally for restricted environments.
End-to-end LLM application development using TypeScript and Python: prompt pipelines, tool use, streaming, structured output, and production deployment.
Master Apache Airflow 3 workflows using Python—from the airflow.sdk authoring interface and asset-based scheduling to DAG versioning, cloud integration, and custom plugins.
Gain in-depth skills to administer and scale Apache Airflow 3—from configuring executors and auth managers to deploying on Kubernetes, upgrading from Airflow 2, and monitoring with OpenTelemetry.
An intermediate-to-advanced 3-day course on running Apache Airflow 3.2 on Kubernetes: the new API Server, Task SDK, and DAG Processor architecture, the Kubernetes Executor and KubernetesPodOperator, Multiple Executors Concurrently, dynamic task mapping, Object Storage XCom, custom operators and providers, and production best practices with OpenLineage and OpenTelemetry observability.
Master data engineering automation—from provisioning infrastructure with Ansible to orchestrating workflows with Apache Airflow and integrating with Snowflake for modern cloud data warehousing.
Streamline workflows with Python by automating file ops, subprocesses, logging, CLI args, async and API tasks—plus optional AI and distributed automation modules.
Gain hands‑on mastery of distributed task automation using Python, Celery & RabbitMQ. Set up Docker environments, define tasks, and scale workflows with routing, scheduling, and deployment.
A hands-on 2-day course for Python developers on building scalable, batch-oriented data pipelines with Apache Kafka 4.x (KRaft mode) and Celery: Kafka topics, consumer groups, and exactly-once semantics, Celery workers backed by Redis, Kafka-to-Celery integration with DLQs and idempotency keys, monitoring with Prometheus, Grafana, and OpenTelemetry, and KEDA-driven autoscaling.
Master distributed task automation with Python Faust and Kafka. Learn to containerize environments, process streaming data, manage state and fault tolerance, monitor systems, and deploy real‑time pipelines.
Learn to build scalable data pipelines with Apache Spark 4 using Python. Gain hands-on experience with Spark Connect, Spark SQL, DataFrames, and real-time processing.
Build custom Jupyter widgets with modern ipywidgets 8.x and AnyWidget: Python widget classes, ESM-based front-ends in TypeScript, packaging, and embedding in JupyterLab and Notebook 7. Replaces the legacy CoffeeScript/Backbone-based widget toolchain.
End-to-end generative AI for Python developers in 2026: frontier models (Claude 5 and 4.x, GPT-5.x, Gemini 3.x), prompt and context engineering, structured outputs, tool use, RAG, agentic patterns with MCP, evals, observability, and responsible deployment.
Build native iOS, Android, Windows, and Mac apps from one C# codebase with .NET 10 MAUI: XAML and compiled bindings, MVVM with source generators, Shell navigation, maps and geolocation, platform integration, offline data, testing, performance, and store deployment.
Reuse your Blazor skills and Razor components to ship native iOS, Android, Windows, and Mac apps with .NET 10 MAUI Blazor Hybrid: BlazorWebView, shared UI across native and web, platform API access, offline data, authentication, testing, and store deployment.
Build .NET 10 MAUI apps test-first: TDD principles applied to MVVM view models, navigation, and platform services; mocking device APIs; data-layer and integration testing; device UI automation with Appium; and CI pipelines that build and test for Android and iOS.
Build .NET 10 MAUI Blazor Hybrid apps test-first: TDD for Razor components with bUnit, mocking platform services and JS interop, testing shared UI across native and web targets, data-layer testing, Appium and Playwright automation, and CI pipelines for hybrid apps.
This course provides an in-depth exploration of ASP.NET Core Blazor and .NET 10, covering new features like the PersistentState attribute, WebAuthn/FIDO2 passkey authentication, and NavigationManager.NotFound(). Learn to build user interfaces with Razor Components, employ QuickGrid for data management, integrate JavaScript, configure routing, implement authentication, and deploy applications to production.
Master ASP.NET Core Blazor and Minimal API with our comprehensive course, covering new .NET 10 and C# 14 features, Razor Components for composable UIs, WebAuthn/FIDO2 passkey authentication, data binding, routing, deployment, server data consumption via REST APIs and SignalR, JavaScript integration, and unit testing for robust application development.
Master ASP.NET Core Blazor and Web API with our comprehensive course, covering new .NET 10 and C# 14 features, Razor Components for composable UIs, WebAuthn/FIDO2 passkey authentication, data binding, routing, deployment, server data consumption via REST APIs and SignalR, JavaScript integration, and unit testing for robust application development.
Become a proficient Test-Driven Development (TDD) practitioner in web development through our comprehensive course, covering TDD principles and best practices, applying TDD to ASP.NET Core 10 and JavaScript/TypeScript code, mastering unit and end-to-end testing, organizing tests effectively, testing for Blazor WebAssembly and ASP.NET Core Minimal APIs including new .NET 10 features like PersistentState components and WebAuthn/passkey authentication flows, using mocks, stubs, and fakes for isolation, and integrating testing into development tools and CI/CD pipelines for high-quality software delivery.
Become a proficient Test-Driven Development (TDD) practitioner in web development through our comprehensive course, covering TDD principles and best practices, applying TDD to ASP.NET Core 10 and JavaScript/TypeScript code, mastering unit and end-to-end testing, organizing tests effectively, testing for Blazor WebAssembly and ASP.NET Core Web APIs including new .NET 10 features like PersistentState components and WebAuthn/passkey authentication flows, using mocks, stubs, and fakes for isolation, and integrating testing into development tools and CI/CD pipelines for high-quality software delivery.
Build production React 19 apps on Next.js 16: App Router, React Server Components, Server Actions, Cache Components with 'use cache', Turbopack (now the default), proxy.ts, the React Compiler, streaming, Server Functions, and end-to-end testing.
Build full-stack React 19 apps with React Router 7 (the framework formerly known as Remix). Loaders, actions, server modules, hydration, progressive enhancement, and a clean alternative to Next.js.
Go deep on client-side React 19: Actions, the use hook, useOptimistic, the React Compiler, Suspense and concurrent rendering, performance profiling with React DevTools, state architecture with TanStack Query and Zustand, custom hooks design, and advanced testing with Vitest.
Build full-stack React apps with TanStack Start: fully type-safe file-based routing with TanStack Router, type-safe server functions, SSR and streaming, data loading with TanStack Query, forms, middleware, and deployment to any modern host.
Master Angular 22 in the signal-first era: Signals, stable Signal Forms, zoneless change detection (the default since Angular 21), the built-in control-flow blocks (@if/@for/@switch), standalone components, typed reactive forms, the modern HttpClient APIs, and end-to-end testing.
Migrate legacy Angular codebases to modern Angular 22: ng update upgrade paths, NgModules to standalone components, built-in control flow, zoneless change detection, RxJS to signals, typed forms and Signal Forms, Karma/Jasmine to Vitest, Protractor to Playwright, and AI-assisted migration at scale.
This course offers a comprehensive guide to Svelte, a modern JavaScript framework, providing a deep understanding of its features and functionalities, with a special focus on comparisons with React to aid learning.
This course provides a comprehensive exploration of Svelte, a modern JavaScript framework, with a focus on comparisons with Angular to facilitate a deeper understanding of its features and functionalities.
Master the innovative JavaScript framework, Svelte, from the basics to advanced features like environment variables, advanced bindings, advanced component composition, advanced routing, actions, UI special effects, special elements, hooks, pages and layout, links, and unit testing with our comprehensive course.
Take your Svelte skills to the next level with our advanced course, covering everything from environment variables, advanced bindings, and component composition to UI special effects, hooks, and unit testing.
This course provides a thorough exploration of Svelte, a modern JavaScript framework, and its integration with ASP.NET Core, offering a comprehensive guide to building full-stack applications.
This course provides a thorough exploration of Svelte, a modern JavaScript framework, and its integration with FastAPI, a Python web framework, offering a comprehensive guide to building full-stack applications.
This course provides a thorough exploration of Svelte, a modern JavaScript framework, and its integration with Flask, a Python web framework, offering a comprehensive guide to building full-stack applications.
Master modern Vue 3: the Composition API with script setup, reactivity (ref, computed, watch), components, Pinia state management, Vue Router 5, forms, TypeScript, Vite tooling, and testing with Vitest and Vue Testing Library.
This course offers a comprehensive guide to modern Vue 3, providing a deep understanding of its features and functionalities, with a special focus on comparisons with React to aid learning.
This course provides a thorough exploration of modern Vue 3 with TypeScript and its integration with FastAPI, a Python web framework, offering a comprehensive guide to building full-stack applications.
Build full-stack HTML-first web apps with HTMX 2.x and a server of your choice (Flask, FastAPI, ASP.NET Core, Express). Master HTMX's request/response model, swaps, triggers, hyperscript, server-sent events, the hx-on event syntax, and progressive enhancement.
Build REST APIs with Python and Flask 3 + Flask-RESTX. Note: Flask-RESTX is in maintenance mode in 2026; the course covers it for teams maintaining existing services and discusses migration paths to FastAPI or APIFlask.
Build production REST APIs with Python and the latest FastAPI: Pydantic 2 models, async SQLAlchemy 2.x, OAuth2/JWT auth, OpenAPI 3.1 docs, lifespan events, dependency injection, and deployment to AWS, Azure, or GCP.
Build production-ready REST APIs in Rust on the 2024 edition with Actix-web 4: routing, extractors, middleware, sqlx-backed data access, observability, and an AI-augmented workflow using Claude Code, Cursor, and GitHub Copilot.
Build framework-agnostic UI with the Web Components platform: Custom Elements (Form-Associated where it matters), Shadow DOM (incl. declarative Shadow DOM and CSS Shadow Parts), HTML Templates, slots, ElementInternals, and Stage 3 decorators.
Production-quality Web Components with Lit 3: reactive properties, lifecycle, Form-Associated Custom Elements, decorators, Shadow Parts, Lit SSR with declarative Shadow DOM, and unit testing with @web/test-runner and Playwright.
Build full-stack web applications in Rust on the 2024 edition with Leptos 0.8: fine-grained reactivity, server functions, the islands router, SSR with hydration, and an AI-augmented workflow using Claude Code, Cursor, and GitHub Copilot.
Build small, fast, secure desktop and mobile apps with Rust on the 2024 edition and Tauri 2: ACL-based capabilities, native context menus, mobile (iOS and Android), and an AI-augmented workflow with Claude Code, Cursor, and GitHub Copilot.
