Full-Stack Web Apps with Rust and Leptos

Class Duration

21 hours of live training delivered over 3-5 days to accommodate your scheduling needs.

Student Prerequisites

Working Rust experience equivalent to Rust Essentials
Familiarity with HTML, CSS, and a modern frontend framework (React, Vue, Svelte, or similar)
Comfort with the command line and Git

Target Audience

Engineers building full-stack web applications who want a single language (Rust) across browser and server, fine-grained reactivity that outperforms virtual-DOM frameworks, and a tight WebAssembly story. Particularly relevant for teams that already run Rust on the backend and want a frontend that shares types, validation, and business logic with the server.

Description

Leptos is a full-stack, isomorphic Rust web framework built on fine-grained reactivity, similar in spirit to SolidJS but with a Rust type system, server functions, and a tight WebAssembly story. This course teaches engineers to build, ship, and operate full-stack Leptos applications on the Rust 2024 edition (1.85 introduced the edition; 1.95+ recommended for the current toolchain) and Leptos 0.8. It covers components, signals and effects, routing including the islands router, server functions and shared types, SSR with hydration, forms and validation, and the full deployment story. Throughout, students use AI coding assistants (Claude Code, Cursor, GitHub Copilot) the way senior Rust engineers actually use them in 2026 — letting Cargo, clippy, and the compiler be the source of truth on the Rust side.

Learning Outcomes

Build full-stack web applications in Rust with Leptos 0.8 from scratch.
Apply fine-grained reactivity using signals, effects, and memos correctly.
Compose components, pass props, render collections, and handle events idiomatically.
Define and call server functions that share types between server and client.
Use the Leptos router, including nested routes, dynamic segments, and the islands router.
Render with SSR, CSR, or SSR-with-hydration and reason about each rendering mode.
Build forms with validation, action forms, and progressive enhancement.
Optimize WebAssembly bundle size and ship a deployable, dockerized application.
Use AI coding assistants effectively for Leptos development without sacrificing safety or correctness.

Training Materials

All students receive comprehensive courseware covering all topics in the course. Courseware is distributed via GitHub in the form of documentation and extensive code samples. Students practice the topics covered through challenging hands-on lab exercises that build into a complete, deployable Leptos full-stack application capstone.

Software Requirements

A free GitHub account, the latest stable Rust toolchain installed via rustup (Rust 1.95+ on the 2024 edition), Visual Studio Code or another supported editor with the rust-analyzer extension, cargo-leptos, Node.js 22+ for tooling, Docker for the local PostgreSQL instance (if the database lab is included), and an AI coding assistant of choice (GitHub Copilot, Cursor, or Claude Code). A cloud-based environment can be provided if local installation is restricted.

Training Topics

Leptos in 2026

WebAssembly and what's changed: bundle sizes, browser support, tooling
What Leptos is: full-stack, isomorphic, fine-grained reactivity
Leptos 0.8 status and roadmap to 1.0
Leptos vs. React, SolidJS, Yew, and Dioxus
Why fine-grained reactivity beats virtual DOM for many workloads

Getting Started

Creating a Leptos project with cargo-leptos
Project layout and the SSR/hydration story
Running and debugging Leptos apps
Hot reload during development

Components

What components are in Leptos
Defining components with #[component]
Props and dynamic attributes
Passing children and the Children type
Component composition patterns

Parent–Child Communication

Communicating from child to parent via write signals and callbacks
Closures vs. callbacks
Event listeners
Context for cross-tree communication

Render Logic

Displaying data and embedding expressions
Conditional rendering
Rendering collections with <For> and stable keys
Error handling with <ErrorBoundary>
Suspense and <Transition>

Event Handling

Handling DOM events idiomatically
Event modifiers and propagation
Form events vs. action forms

Reactivity with Signals

What signals actually are
The four signal operations: read, write, derive, dispose
Effects and dependency tracking
Memos and when to reach for them
Common reactivity pitfalls

Routing

The Leptos router
Defining routes and nested routes
Path parameters and queries
Links, forms, and the islands router
Loaders and data dependencies

Server Functions and Shared Types

What server functions are and why they're load-bearing
Defining server functions with #[server]
Shared types between server and client
Extractors and responses
Redirects, cookies, and headers

Forms

Plain HTML forms in Leptos
Action forms and progressive enhancement
Form validation patterns
File uploads

Metadata and Styling

The Leptos meta package: title, meta tags, links
Styling approaches: scoped CSS, Tailwind, CSS modules, styled components
Asset pipelines and content hashing

SSR, CSR, and Hydration

What server-side rendering actually buys you
Client-side rendering tradeoffs
SSR with hydration: how Leptos does it
The islands router and partial hydration
Choosing a rendering mode per route

Database and Backend Integration

Calling sqlx and PostgreSQL from server functions
Connecting Leptos to an Actix-web or Axum backend
WebSockets via server functions
Authentication patterns

Testing

Unit testing components
E2E testing with Playwright
Snapshot testing the rendered output

Deployment

Building a Leptos application for production
Optimizing WASM size: wasm-opt, wee_alloc, feature flags
Multi-stage Docker builds for full-stack Leptos
Hosting considerations: bare metal, VMs, container platforms, edge

AI-Assisted Leptos Development

Where AI assistants help on Leptos boilerplate (components, server functions, routes) and where they fall short (reactivity timing, hydration mismatches)
Prompts that work well for Leptos component design
Letting the compiler, clippy, and tests catch what AI gets wrong
Reviewing AI-generated server functions for trust boundaries
Agentic Rust workflows for Leptos: AI-assisted refactors, code review, and CI

Capstone

Build and deploy a complete full-stack Leptos 0.8 application: components, signals, the islands router, server functions backed by sqlx and PostgreSQL, action forms, SSR with hydration, an optimized WASM bundle, and a Docker image — built with AI assistance and validated by the compiler, clippy, tests, and a Lighthouse run
Course wrap-up and recommended next courses