Serverless started with AWS Lambda as a way to use spare compute capacity. Developers wrote small pieces of code that would handle events, process them, and shut down - without maintaining long-running servers. This was revolutionary but had significant growing pains as adoption grew.
In a recent Software Plaza podcast, Twain Taylor, editor at Software Plaza, discussed these issues with Matt Butcher, CEO of Firmian, who revealed how WebAssembly is emerging as a powerful solution for overcoming the limitations of conventional serverless architectures.
Evolution and limitations of traditional serverless
As serverless got popular, cloud providers had to maintain massive queues of pre-warmed virtual machines to handle incoming requests with acceptable performance. This went against the original efficiency goals of serverless and resulted in significant resource waste. Virtual machines and containers are great for long-running workloads, but they have substantial startup penalties that create performance problems for event-driven, short-lived functions.
These limitations manifest in several ways:
- Cold start delays of several seconds are impacting the user experience
- High infrastructure costs from idle resources
- Inefficient resource utilization with pre-allocated memory and CPU sitting idle
- Operational complexity in managing these environments
Organizations running serverless at scale are paying for much more compute than they use, defeating one of the main benefits of serverless.
WebAssembly: A runtime for serverless
WebAssembly (Wasm) is a purpose-built runtime for serverless workloads. Originally developed by Mozilla, Google, Microsoft, and Apple for the browser, WebAssembly provides a secure, high-performance runtime that can start and stop in nearly an instant.
The benefits of WebAssembly for serverless applications are:
- Instant startup: Cold starts are measured in milliseconds, not seconds.
- Memory efficiency: Much lower memory footprint than VMs or containers
- Security by design: Sandboxed execution environment with strong isolation properties
- Language flexibility: Support for multiple languages, including JavaScript, Rust, C/C++, Go, and Python
Building serverless with Spin
Spin is an open source developer framework for building WebAssembly serverless applications. Part of the Cloud Native Computing Foundation (CNCF), Spin provides a streamlined way to create, test, and deploy serverless functions in multiple languages.
The Spin workflow is super simple:
- Create a new app with spin new
- Write your code in your preferred language (JavaScript, TypeScript, Rust, Python, Go, etc.)
- Build it with spin build
- Test locally using spin up
- Deploy to production with a single command: spin deploy
This abstracts away a lot of the complexity of working with WebAssembly directly, so you can focus on business logic, not infrastructure. The multi-language support also lets you leverage your existing skills while getting the benefits of WebAssembly.
Kubernetes integration: Running WebAssembly alongside containers
If you’re already invested in Kubernetes, you don’t have to abandon your existing infrastructure. Spin Kube lets you run WebAssembly workloads alongside containerized applications in your Kubernetes cluster.
This works at the containerd layer, so the container runtime schedules and runs the WebAssembly workloads. The result is a seamless experience where WebAssembly functions can be described using familiar Kubernetes concepts like pods and deployments.
The benefits are huge:
- Resource optimization: One customer reduced their Kubernetes cluster size by 40% by moving some workloads from containers to WebAssembly
- Speed: WebAssembly functions start in 0.5ms vs 10-12 seconds for containers
- Density: Run thousands of functions on the same infrastructure that previously supported dozens of containers
- Familiar tooling: Use your existing Kubernetes knowledge and tools to manage WebAssembly applications
Edge computing with WebAssembly
WebAssembly is so efficient and portable that it’s perfect for edge computing. Running serverless functions at the edge—closer to the user—can be a huge performance and cost win. But traditional serverless implementations are too resource-intensive to deploy across thousands of edge locations.
These capabilities were only available to the biggest organizations with the biggest infrastructure budgets. WebAssembly makes edge computing accessible to everyone.
Real-world applications and performance impacts
Companies using WebAssembly for serverless are seeing real results across various industries:
Cost savings
Moving from long-running containers to event-driven WebAssembly functions can reduce infrastructure costs. WebAssembly workloads are denser, so fewer servers are needed to handle the same traffic. One manufacturing company reduced its Kubernetes cluster by 40% while handling more traffic from a new large customer.
AI at the edge
The rise of AI has created new opportunities and challenges for edge computing. WebAssembly enables efficient inference at the edge, so personalization and intelligent processing without the latency of communicating with central servers. For e-commerce applications, this means personalized recommendations can be generated on the fly based on user behavior and preferences.
Bot protection and content security
The proliferation of AI crawlers and bots is a new challenge for content owners. WebAssembly functions at the edge can detect bot traffic and dynamically modify content to protect intellectual property while still allowing legitimate indexing. This balances discoverability with content protection.
Implementation strategy and best practices
Companies looking to use WebAssembly for serverless applications should follow this approach:
- Identify the right workloads: Start with event-driven, stateless functions that would benefit from faster startup times and lower resource usage
- Choose the right tools: Use Spin to simplify development and deployment
- Consider a hybrid approach: Run WebAssembly alongside containers rather than replacing everything at once
- Leverage edge capabilities: Deploy functions close to users for better performance
- Monitor and optimize: Track performance metrics to ensure optimal resource usage
You don’t have to go all in. Many companies achieve success by moving specific workloads to WebAssembly and keeping the rest of their infrastructure.
The future of serverless with WebAssembly
Serverless and WebAssembly are a return to the original vision of serverless: efficient use of compute resources with a simpler developer experience. As companies are under pressure to optimize costs while delivering great performance, this is a good path forward. Serverless at scale is hard, but WebAssembly is a purpose-built solution that solves the problems and opens up edge computing and more. By using this technology, you can finally overcome the barriers that have been holding you back from fully realizing the benefits of serverless.
Watch the full webinar to learn more.
