- EN
- JA
- ES
- DE
- FR
Serverless compute environment
Scalable. Performant. Safe. All at the edge.
Execute your code globally without having to provision your own servers or manage infrastructure. Move logic to the edge to deliver near real-time responses and create fast, seamless online experiences.
From the beginning, Fastly was built to keep data at the edge — closer to end users — for faster web and app performance. As modern apps become more personalized, there’s also a growing need for low-latency data processing at the edge. This is where our serverless compute environment comes into play.
Fastly’s serverless compute environment
Fastly’s serverless compute environment is built on top of our advanced caching platform and is a general computing layer that sits between single- or multi-origin clouds and your end users. It’s designed to address the requirements of modern app development by empowering customers to run code in a safe, microsecond execution environment, at scale, on the edge.
Edge serverless
Users are routed to a centralized logic server
How serverless helps you
Seamless scalability
Deploy and run complex logic for any application or backend service with our secure, performant, and scalable approach to serverless computing.
Increased security
Run applications and execute code at the edge with built-in security and without having to manage the underlying infrastructure.
Simplify operations
Avoid the challenges that typically come with outsourcing infrastructure and reduce the operational burden on your teams.
How we built it
We built our serverless compute environment on truly innovative technology.
WebAssembly
We could have relied on existing technologies for serverless compute — like reusable containers — but this approach was hindered by performance and scale limitations. Instead we chose to build our serverless compute platform on WebAssembly, a technology we’ve been collaborating on with the Bytecode Alliance. WebAssembly is uniquely suited to empower you to write code in your preferred language, then run that code anywhere at near-native speeds.
Lucet
The Chromium V8 engine is typically used to compile and run code on WebAssembly but with significant added latency. We wanted to eliminate cold start times for our customers so we built Lucet — our own compiler and runtime engine. With a 35.4 microsecond startup time, Lucet ensures extremely fast code execution with no cold starts or roundtrip delays. Just fast, always-on computing.
Isolated sandboxing
The distributed nature of edge compute means you need to run logic for multiple customer apps in parallel, and that can introduce vulnerabilities and contention over resources. To address this, we built a secure sandbox environment to create and destroy each request as it flows through our platform. Operating within microseconds, this cutting-edge technology reduces the attack surface and eliminates side channel attacks while providing a safer environment for developers to innovate.
Execute faster. Much faster.
At 35.4 microseconds, Compute provides a 100x faster code execution startup time than other serverless solutions. Run even your most complex code globally, on 100s of servers strategically located close to end users.
Join us at the Bytecode Alliance
Fastly has teamed up with Mozilla, Intel, and Red Hat to form the Bytecode Alliance, an open-source community working together on WebAssembly-based compiler tools and foundations that work across many platforms.
Today the ByteCode Alliance has established an extremely secure platform that enables application developers and service providers to confidently run third-party code, on any infrastructure, for any operating system or device. Together, we’re developing tools and standards that will help the developer community run code on clients, servers, and the edge, minimizing rework and maximizing reach.
- Products
- Solutions
- Learn
- Support
- Company
- Compare