Call usTry Fastly free

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@Edge 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.  

Explore Bytecode Alliance