WebAssembly on Thorsten Hans

Out Now: Building Serverless Applications with WebAssembly & Spin

Tue, 13 Oct 2026 08:45:00 +0200

Hey friends 👋🏼,

The wait is finally over! After countless early mornings, extensive refactorings, and hours spent obsessing over every code sample and diagram, the first version of Building Serverless Applications with WebAssembly & Spin is officially live.

You can grab your copy right now on Leanpub:

👉 https://leanpub.com/building-serverless-apps-with-wasm-and-spin

Building Serverless Applications with WebAssembly & Spin

What the Book Is About

Server-side WebAssembly represents the next major evolution in cloud architecture. By combining sub-millisecond cold starts, near-native performance, and robust sandboxed isolation, Wasm components eliminate the overhead of traditional containers and function-as-a-service platforms.

I’m Writing a Book on WebAssembly and Spin

Sat, 15 Aug 2026 14:05:00 +0200

Hey friends 👋🏼,

If you’ve been following my activities over the recent years, you know I can’t stop talking about the third wave of cloud computing. Server-side WebAssembly is completely changing the game for cold-start latency and container bloat.

Today, I’m thrilled to announce I’m turning those talks and architectural patterns into a practical, hands-on guide:

Building Serverless Applications With WebAssembly & Spin

Sign up and Stay in the Loop

Instead of theoretical fluff, I structure the book in a way that readers will build a complete, multi-component serverless application from the ground up using Rust and Spin.

Component Composition with Spin 4.0

Fri, 14 Aug 2026 19:15:00 +0200

Thanks to the WebAssembly Component Model we can stitch together multiple WebAssembly Components. Reusing Wasm Components boost developer velocity dramatically while language barriers vanish. In this hands-on article, I’ll explain how you can compose Wasm Components using Spin 4.0.

What You Need To Follow Along

I’ll try to keep things as simple as possible. That’s why we’ll implement both components using Rust, resulting in the following - short - list of requirements:

Azure DevOps Extensions for Spin, Fermyon Wasm Functions and Fermyon Cloud

Thu, 16 Oct 2025 10:15:00 +0200

Do you want to build and deploy your Spin applications from within Azure DevOps pipelines? No matter if you want to target Fermyon Wasm Functions or Fermyon Cloud , the extensions I published to the Visual Studio Marketplace are here to help.

Earlier today I published three distinct extensions for Azure DevOps allowing you to do all-the-things Spin, Fermyon Cloud and Fermyon Wasm Functions straight from within your Azure DevOps pipelines.

What I’ve Been Up To

Wed, 15 Oct 2025 10:15:00 +0200

Although this blog became a bit quite recently, I wrote a bunch of articles over on our corporate blog . I thought it’s worth sharing a comprehensive list of the posts I wrote:

OpenAPI Documentation for Spin Apps with Rust In this guide, I’ll show you how to generate OpenAPI Specification (OAS) documentation directly from Spin apps written in Rust. You’ll learn how this improves API discoverability, speeds up onboarding, and unlocks tooling like SDK generation and testing.
Supercharging Spin Applications with Wizer In this post, I’ll demonstrate how to use the WebAssembly pre-initializer Wizer to preload data into Spin apps — to speed up request processing. You’ll see how this technique makes your apps launch instantly and respond with near-zero latency.
Why We Chose Rust For Spin In this article, I’ll explain why we built Spin in Rust and how its memory safety, speed, and ecosystem made it the perfect fit. I’ll also share how Rust’s tooling and developer experience align with our vision for Spin.
Authoring Custom Spin Templates In this tutorial, I’ll walk you through creating your own custom Spin templates so you can scaffold projects with consistent structure and boilerplate. This is especially helpful if you want to speed up “Sprint Zero” or enforce team best practices.
Spin JS/TS Router Showdown: Hono vs Itty vs Manual Routing In this post, I’ll compare three ways to handle routing in Spin JavaScript/TypeScript apps: Hono, Itty, and manual routing. You’ll see how each approach affects startup time, runtime performance, and memory usage.
Routing in Spin Apps with Hono In this article, I’ll show you how to use the lightweight Hono Router with Spin now that the SDK no longer ships with a built-in router. You’ll learn how to build clean, expressive routes with middleware support using a familiar Express-style API.
Stream Data from Linode Object Storage using the AWS S3 SDK In this tutorial, I’ll teach you how to build a Spin app that streams files directly from Linode Object Storage using the AWS S3 SDK. You’ll learn how to set up access, stream large files, and deploy the app to Fermyon Wasm Functions.
Software Bill of Materials (SBOM) for your Spin Apps In this post, I’ll explain what an SBOM is and why it’s essential for security and compliance in modern applications. Then I’ll show you how to generate SBOMs for your Spin apps to make your supply chain transparent and safe.
Advent of Spin 2024 Wrap-up In this wrap-up, I’ll recap the Advent of Spin 2024 coding challenges and share some of the most creative solutions from the community. You’ll see how developers built festive apps, learned new languages, and had fun experimenting with Spin.
Scaling Spin Apps With KEDA In this article, I’ll show you how to scale Spin apps dynamically on Kubernetes using SpinKube and KEDA. You’ll learn how to set up autoscaling so your apps respond to real traffic while saving on resources.
Announcing Advent of Spin 2024 In this announcement, I’ll introduce the Advent of Spin 2024 — a series of holiday coding challenges to help you explore Spin and related tools. I’ll explain how to join, what you’ll build, and what prizes you can win.
Observing Spin Apps with OpenTelemetry and the .NET Aspire Dashboard In this guide, I’ll show you how to observe Spin apps by exporting metrics, traces, and logs with OpenTelemetry and visualizing them in the .NET Aspire Dashboard. You’ll see how easy it is to get deep insights into your apps with minimal setup.
Spin gh – Generate GitHub Actions for your Spin Apps in seconds In this post, I’ll introduce you to spin gh, a plugin that generates GitHub Actions workflows for your Spin apps in seconds. You’ll learn how to install it, extend your CLI with plugins, and simplify your CI/CD pipeline.
WebAssembly Jobs and CronJobs in Kubernetes with SpinKube & the Spin Command Trigger In this tutorial, I’ll show you how to run Spin apps as Kubernetes Jobs and CronJobs using the command trigger with SpinKube. You’ll learn how to schedule recurring workloads or run one-off tasks in a Wasm-powered environment.
Azure Cache for Redis as Key-Value Store with SpinKube In this guide, I’ll walk you through connecting a Spin app on AKS to Azure Cache for Redis with secure networking using Private Endpoints. You’ll see how to use Redis as a scalable key-value store for your Spin workloads.
Building Serverless Apps with Spin and HTMX In this tutorial, I’ll show you how to build a lightweight shopping list app using Spin on the backend and htmx for the frontend. You’ll learn how to make dynamic UIs without heavy JavaScript frameworks.
WebAssembly in Azure with Azure Kubernetes Service and SpinKube In this article, I’ll walk you through running WebAssembly workloads on Azure Kubernetes Service with SpinKube. You’ll learn how to integrate Spin apps with AKS, Azure Container Registry, and Azure Identities for secure deployments.

WebAssembly and Containers with Docker Desktop - Hello World & Beyond

Wed, 28 Feb 2024 15:27:55 +0100

On top of being the runtime for containers, Docker Desktop is also able to run WebAssembly (Wasm) workloads. In this article, we’ll explore how one can run both containers and Wasm workloads together to build distributed architectures using the best of both worlds.

Beta Feature: Wasm workloads in Docker Desktop is currently marked as a beta feature.

What we are going to build

Discovering new topics, or learning emerging technologies often goes best when looking at a practical example. For the sake of this article, we’ll start with a simple Hello, World. From there, we’ll move on and orchestrate a simple three-tier application consisting of two containers (frontend and postgres) and a Wasm module (api).

Wasm ahead - Joining Fermyon

Mon, 08 Jan 2024 12:05:52 +0100

Hey everyone 👋🏼

A couple of weeks ago, I wrote about my farewell to Thinktecture . After sharing that news back in December, many readers, followers, and friends reached out to ask what my next chapter would be. It was really hard not to share the news right away, but I had to wait for the right time.

I am more than excited to finally unveil that I will join Fermyon as a Cloud Advocate starting February 1st, 2024. 🎉

A comprehensive guide on authoring plugins for Fermyon Spin

Fri, 25 Aug 2023 10:05:15 +0200

Did you know that you can extend the spin CLI with custom plugins that integrate seamlessly and feel like functionality provided by Fermyon itself?

No? No problem!

In this article, we will explore how I build the check-for-update plugin - a simple Spin plugin that allows you to check if your local installation of the spin CLI is outdated. On top of building the actual Spin Plugin, we’ll also go through the process of testing and distributing the check-for-update plugin. Finally we’ll wrap up this article by adding the custom Spin Plugin to the Spin Up Hub, to ensure users can discover it.

How to use Azure Cosmos DB as a key-value store for Fermyon Spin

Fri, 26 May 2023 10:04:05 +0200

With the 1.2.1 release of Fermyon Spin, we can now use Azure Cosmos DB as a key-value store for persisting data when building serverless applications. In this article, I guide you through setting up the necessary infrastructure and creating a fairly simple app to store and retrieve arbitrary values using Azure Cosmos DB as the key-value store.

All code shown in this article is also available on GitHub at https://github.com/ThorstenHans/spin-kv-azure-cosmosdb .

How I replaced the backend of my blog with Spin & Fermyon Cloud

Thu, 04 May 2023 15:53:49 +0200

Although my blog is built using Hugo - a famous Static Site Generator - I’ve some functionality baked into the page that requires having a backend (basically an HTTP API). Historically, the backend was hosted in Azure leveraging Azure Container Apps. Recently, I replaced the entire backend for my blog using a Fermyon Spin application hosted in the fully managed Fermyon Cloud . In this article, I explain how I migrated away from containers towards server-side WebAssembly with Fermyon Spin 💫.

A First Glance at the Spin Router for Rust

Tue, 18 Apr 2023 13:02:41 +0200

With the release of Fermyon Spin 1.1 (April 15th, 2023), the Spin SDKs for Rust and Go now provide a built-in router for HTTP applications. In this post, we will take a quick look at the built-in router supplied by the Spin SDK for Rust and build a small sample application to illustrate how one could solve day-to-day requirements when building serverless applications with WebAssembly (Wasm).

What’s the purpose of a router in HTTP apps?

In HTTP applications, a router serves as a central component to direct incoming HTTP requests to the appropriate handler functions that can process and respond to those requests. The router does so by looking at different parts of an incoming HTTP request, such as:

Let's build a HTTP router for Spin with Rust

Fri, 14 Apr 2023 11:13:43 +0200

Although we can build more complex HTTP applications in Fermyon Spin by composing multiple components, having a single component is easier, reduces development time, and is more flexible in the first place. In this article, I will explain how to implement simple routing capabilities using enumerations in Rust.

Let Spin lift your key-value store

Sat, 08 Apr 2023 15:41:09 +0200

For quite sometime now (since version 0.9.0), Spin has had built-in key-value support. In this article, we will quickly investigate how we can use that built-in key-value support when building serverless applications with Fermyon Spin.

What are key-value stores

A key-value store is a type of database that stores data as a collection of key-value pairs. Each key in the database maps to a corresponding value, which can be retrieved by querying the key. Key-value stores are often used for storing and retrieving data quickly, as they can perform reads and writes with very low latency. They are commonly used in web applications, caching layers, and distributed systems and can be implemented using various technologies, such as Redis, Cassandra, etcd, SQLite, and others.

CRUD in WebAssembly with Fermyon Spin and MySQL

Tue, 20 Dec 2022 16:32:11 +0100

With the latest release of Fermyon Spin (v 0.7.0), we can persist data in MySQL (persistence in PostgreSQL has been available for quite some time now). Being able to persist and retrieve some sort of data is a must-have for any kind of application.

In this article, we’ll take a look at a full-fledged CRUD implementation. We’ll build an HTTP-API that allows its users to Create, Read, Update, and Delete products using corresponding HTTP methods (POST, GET, PUT, and DELETE). All code shown in this article is available on GitHub at ThorstenHans/spin-crud-mysql .

Master configuration data in Fermyon Spin

Thu, 15 Dec 2022 14:01:01 +0100

Every application has to deal with configuration data, and applications built using Fermyon Spin are no exception here. Instead of baking configuration data into your source code, you should attach it from the outside to alter behavior of your applications without having to re-compile your source code.

This short article demonstrates how to deal with configuration data when building applications using WebAssembly and Fermyon Spin. You can find the source code of the sample application (spin-to-slack) on GitHub at ThorstenHans/spin-to-slack .

Building Microservices With WebAssembly and Fermyon Spin

Sun, 11 Dec 2022 15:18:16 +0100

Although WebAssembly is an excellent fit for bringing complex solutions that need near-native runtime performance to the client (Browser), I see WebAssembly as a technology with way more potential and a way bigger impact on the server (read: cloud) in contrast. That said, WebAssembly will not replace containers on the server side. It’s an addition or alternative approach to packaging and distributing specific software components typically part of a bigger system. It’s on us - the developers and software architects - to decide if a container or WebAssembly is the better foundation for meeting a particular requirement.