hosting
Fastly Compute v8 Turns Static Publishing Into a Versioned Edge Workflow
Fastly Compute JS Static Publish v8 separates site content from application code and adds object storage, named collections, and preview workflows for static sites served at the edge.
Static websites are easy to build and surprisingly easy to make awkward to publish. A team can have a clean build pipeline, yet still wrestle with package limits, staging copies, cache invalidation, and the question of how to preview one pull request without disturbing the live site.
Fastly’s announcement on November 11, 2026, puts a new shape around that problem. Version 8 of Compute JS Static Publish adds Object Storage support, named collections, and preview URLs. The notable change is not simply that a static site can run at the edge. It is that publishing becomes a versioned workflow around the content itself.
The before-and-after is about where content lives
Fastly’s earlier approach could package static files inside the application. That was simple, but content was coupled to the deployed application: a content change meant another build and deploy, and the site had to fit within the relevant package constraints.
Fastly says later versions moved the files into KV Store, so content could be published separately from the Compute application. Version 8 adds another option: Fastly Object Storage, or another S3-compatible storage service. Object Storage is currently described as a beta option, while KV Store remains the default. The practical result is a cleaner separation between application code and the files the application serves.
That separation matters for teams that update content frequently but do not want to redeploy edge code for every change. The application can remain stable while a new collection of files is uploaded and selected for serving.
Named collections turn deployments into versions
The most useful idea in the release is the collection. Fastly describes a collection as a named set of files plus the server settings associated with it. A project can keep a live collection, a staging collection, and short-lived preview collections beside one another.
That gives a static publishing pipeline a clearer before-and-after. Instead of overwriting one directory and hoping the cache and reviewers see the right build, a team can publish a new collection, inspect it, and promote it when ready. Fastly’s example uses an expiration time for a staging collection, which is a useful detail for preview environments that should not live forever.
Collection selection can be driven by a hostname, cookie, header, URL path, or a value in Fastly Config Store, according to the company. That makes the workflow flexible enough for a preview subdomain, an internal review header, or a controlled staging path.
A concrete pull-request workflow
Imagine a documentation site generated from Markdown. A pull request changes navigation, code samples, and a few images. With a collection-based workflow, the build system can publish those files into a collection named for the pull request and give reviewers a preview address. The preview can expire after a set period, so abandoned branches do not remain part of the serving surface indefinitely.
After review, the same workflow can promote the tested collection to live. The application code does not need to change just because the content changed. The content release and the edge application release become two related but separate events.
This is a workflow example, not a guarantee that every project will need the same routing model. Teams still have to decide how preview hostnames are created, how credentials are handled, how branches are cleaned up, and which collection should answer a production request.
Object Storage changes the storage trade-off
Fastly says files in KV Store are content-addressed, so identical files are stored only once, including across publishes. It also says larger files can be split into chunks behind the scenes. Object Storage keeps files in one piece and can use Fastly’s own storage or an S3-compatible service.
The choice is therefore not just “which backend is faster.” It is also about operating model. KV Store remains the default and is integrated with the existing publisher flow. Object Storage can be a useful fit when a team wants S3-compatible storage, wants to bring its own bucket, or wants to evaluate a different cost and file-management model. Fastly labels the Object Storage support beta, so the trade-off includes the maturity of that path.
Publishing is also getting more operational detail
Version 8 expands the command-line workflow with commands for publishing content, cleaning unused files, and managing collections. The project’s official GitHub repository contains the implementation and configuration details. Fastly says mutating commands support dry runs, which lets a team inspect the intended change before it reaches storage.
The release also describes automatic purging after content publishing and collection deletion, parallel scanning and compression, skipping unchanged files, and optional response caching. Text assets can be stored in Brotli and gzip variants, while conditional requests can return 304 Not Modified when a browser already has the current copy. These details do not replace a deployment process, but they make the publishing path more observable and repeatable.
For a team debugging a preview or cache issue, the optional server-timing header is especially practical. It can show whether a response came from cache and help explain where time was spent, rather than leaving the team to infer behavior from page-load impressions.
Where the JavaScript layer still matters
The tool can serve a static site without custom code, but Fastly emphasizes that the generated project is still a regular Compute application written in JavaScript. The PublisherServer handles common static concerns such as index files, 404 responses, SPA fallbacks, compression, and caching headers. When it cannot handle a request, application code can add its own behavior.
That creates room for redirects, authentication checks, A/B testing, collection selection, or a small API endpoint around the static content. The distinction is useful: v8 is not only a managed file uploader, but it also does not require a team to write edge logic just to serve a folder of files.
The trade-offs before adopting it
Fastly Compute v8 is most relevant to static sites, documentation portals, frontend builds, and edge applications that benefit from versioned content. It is less of a direct answer for a workload whose main behavior depends on a database-backed origin, a server-rendered application, or a CMS that must execute at request time. In those cases, the static layer may still be only one part of the architecture.
Teams should also separate the stable parts of the release from the beta path. KV Store is the default; Object Storage is optional and currently beta. A production workflow should define how collections are named, expired, promoted, purged, and audited. It should also keep development storage separate from production storage, a point Fastly calls out for local work.
Fastly Compute v8 makes static publishing look less like copying files and more like managing releases. That shift is the real story. A live site, a staging build, and a pull-request preview can become deliberate states in one edge workflow, while application code, content storage, and review remain easier to reason about.
This article is a general information summary based on the cited public sources. It is not legal, cybersecurity, or compliance advice.