TechPrufer
Get started
Cloudflare
Cloudflare logoCloudflare · Feature trail

Edge Computing with Cloudflare Workers

9 posts · Feb 2018 – Apr 2025

What this trail covers

Cloudflare Workers has evolved into a powerful edge computing platform, enabling developers to run serverless JavaScript code globally. This post announces the open beta, highlighting the ability to intercept and modify requests, make outbound requests, and deploy globally in under 30 seconds. It provides examples for A/B testing, conditional routing, request filtering, response aggregation, and hotlink protection, with code available on GitHub and a community forum for feedback. Wrangler v2.0 s

All Cloudflare trails
  1. Startup spotlight: building AI agents and accelerating innovation with Cohort #5This post details how startups Lamatic.ai and Skyward AI are leveraging Cloudflare Workers and related services to build and scale AI agent platforms. Lamatic.ai uses Workers for low-latency request processing, Workers for Platforms for per-customer deployments, Workers KV for secure credential storage, and Queues for orchestrating ETL and event-driven workflows. Skyward AI uses Workers for request handling, Durable Objects for state management in compliance sessions, AI Gateway for observability, and R2 for long-term storage. Skyward AI has also transitioned to Cloudflare's new AI agents framework, simplifying agent communication while preserving data privacy and isolation benefits previously provided by Durable Objects.
  2. Your frontend, backend, and database — now in one Cloudflare WorkerThis post announces significant improvements to building full-stack applications on Cloudflare Workers. Key contributions include: general availability (GA) support for multiple frontend frameworks (React Router v7/Remix, Astro, Hono, Vue.js, Nuxt, Svelte/SvelteKit), with more to follow (Next.js, Angular, SolidJS). It highlights the ability to build full-stack apps without a framework using Vite + React, with a backend API in the same Worker. The Next.js adapter (@opennextjs/cloudflare) is now v1.0-beta. The Cloudflare Vite plugin is GA and supports Hot Module Replacement within the Workers runtime. Static _headers and _redirects files are now supported. MySQL databases can be connected via Hyperdrive, in addition to PostgreSQL. More Node.js APIs (crypto, tls, net, dns) are available, and the maximum CPU time for a Worker request has increased to 5 minutes. Workers Builds now supports deploying from GitHub/GitLab repositories and running on non-production branches with preview URLs posted back to GitHub. The Images binding is now GA. The post also emphasizes that Workers is now the primary platform for building full-stack apps, converging features from Cloudflare Pages, and offers enhanced observability and gradual deployment capabilities.
  3. “Just use Vite”… with the Workers runtimeThis post announces the 1.0 release of the Cloudflare Vite plugin and official support for React Router v7. The Cloudflare Vite plugin enables the Vite dev server to run Worker code directly within the native Cloudflare Workers runtime (workerd) using Vite's new Environment API. This allows for a more accurate development experience, mirroring production behavior for SPAs and full-stack applications. The plugin integrates with Workers Assets for static asset handling and allows for seamless development of Worker backends. It also supports `vite build`, `vite preview`, and `wrangler deploy` for a unified development and deployment workflow. First-class support for React Router v7 is integrated, allowing direct access to Workers runtime features like `env` and `ctx` within the application's request handler.
  4. Piecing together the Agent puzzle: MCP, authentication & authorization, and Durable Objects free tierThis post introduces new capabilities for the Agents SDK, enabling AI agents to act as remote MCP clients with built-in transport and authentication. It details the `MCPClientManager` class for managing multiple MCP connections, including capability discovery and namespacing. Integrations with Stytch, Auth0, and WorkOS are highlighted for simplifying MCP server authentication and authorization. The post also announces the inclusion of Durable Objects in the free tier, making them accessible for agent development, and the GA release of Workflows for long-running agent actions.
  5. Making Cloudflare the best platform for building AI AgentsThis post introduces the `agents-sdk` framework for building AI agents on Cloudflare Workers, enabling autonomous task execution with features like real-time communication, state persistence, and tool integration. It also details updates to Workers AI, including JSON mode for structured outputs, longer context windows, and improved tool calling, which are crucial for agent functionality. The post highlights the integration of these capabilities with Durable Objects for scalable state management and React applications via the `useAgent` hook.
  7. Hardening Workers KVThis post details the investigation and remediation of multiple incidents impacting Workers KV due to issues with a new backend architecture and a flawed progressive release process. It highlights an observability gap in error reporting for Workers, a mutation of global state perceived as request-scoped, and a bug in the deployment logic that led to traffic black-holing. The post emphasizes the need for hardening the progressive release process and improving unhandled exception reporting.
  8. Keep track of Workers’ code and configuration changes with DeploymentsThis post introduces 'Deployments' for Cloudflare Workers, a new feature that allows developers to track changes to their Worker code, configuration, and bindings. It provides an audit log of who made changes, where they came from, and when they were made, with initial support for wrangler, API, dashboard, and Terraform. The feature is currently in open beta and lays the foundation for future enhancements like automated deployments and rollbacks.
  9. Durable Objects Alarms — a wake-up call for your applicationsIntroduces Durable Objects Alarms, a new feature allowing Durable Objects to schedule their own future execution via an `alarm()` handler. This provides guaranteed at-least-once execution and fault tolerance, enabling use cases like queues and deferred processing. Alarms are distinct from Cron Triggers in their granularity and programmatic scheduling. The implementation involves adding the `durable_object_alarms` compatibility flag and using `state.storage.setAlarm()` and `state.storage.getAlarm()`. Alarms are fault-tolerant by leveraging the same distributed datastore as Durable Object storage and have internal leader election mechanisms within data centers.
  10. 10 things I love about Wrangler v2.0Wrangler v2.0 introduces significant improvements to the developer experience for Cloudflare Workers. Key enhancements include: simplified installation via `npm install wrangler`, zero-configuration startup by inferring project details, a one-liner `wrangler init <project name> -y` command for setting up production-grade projects (including TypeScript and Git), a `--local` development mode powered by Miniflare for offline iteration and CI testing, on-demand log tailing via `npx wrangler tail <worker name>`, enhanced error and warning messages with actionable guidance, integrated debugging tools accessible via the 'D' hotkey or VS Code, native support for npm modules and experimental Node.js compatibility mode, and resolution of hundreds of previously outstanding issues. The release signifies a commitment to continuous improvement based on user feedback.
  11. Production ready eBPF, or how we fixed the BSD socket APIThis post introduces 'tubular', a production-ready eBPF tooling developed by Cloudflare to address limitations of the BSD socket API. It enables advanced network traffic management at the edge, allowing for dynamic changes to service addresses, handling millions of IPs, and managing overlapping port/address configurations for products like Spectrum and DNS resolution. The post details the architecture of tubular, its user interface for managing bindings and sockets, and its use of eBPF maps for state storage and precedence encoding.
  12. A Workers optimization that reduces your billThis post details a significant optimization to the Cloudflare Workers runtime that reduces billing duration for Unbound Workers. The change allows the system to mark application code as 'idle' as soon as response headers are returned, even if the response body is still streaming. This optimization also applies to WebSocket proxying, reading from the cache, and streaming from KV, leading to an average reduction of 70% in the time a Worker is considered 'in use' and thus reducing customer bills.
  13. Cloudflare acquires Zaraz to enable cloud loading of third-party toolsCloudflare acquires Zaraz, integrating its third-party tool management capabilities into Cloudflare's platform, specifically leveraging Cloudflare Workers. This enables cloud-based loading of third-party tools, improving website performance, privacy, and security by offloading execution from the browser to the edge. The product offers a beta version with a library of 18 tools, backward compatibility with Google Tag Manager's dataLayer, and an Events API for complex integrations. Instacart is highlighted as a customer achieving significant improvements in Total Blocking Time, Time to Interactive, and CPU Time by using Zaraz.
  14. Developer Spotlight: Winning a Game Jam with Jamstack and Durable ObjectsThis post details the use of Durable Objects to create on-demand, geographically distributed game rooms for a game jam entry. It explains the architecture for coordinating room codes with a central Durable Object ('Room Hub') and how individual game rooms (also Durable Objects) handle message passing between a host (laptop) and peers (smartphone controller) over WebSockets. The implementation leverages the Durable Objects chat room example and discusses strategies for room code generation and management to ensure low latency.
  15. Durable Objects — now Generally AvailableDurable Objects are now generally available and production-ready. They provide a programming paradigm for coordinating state across Workers at the edge, offering a simpler alternative to traditional databases for global scale and heavy concurrency. Key features include named, unique instances of JavaScript classes that process messages in-order on a single thread, a strongly consistent key-value storage API, and automatic lifecycle management. Durable Objects have been used to power R2 storage and Cloudflare Waiting Room, and have enabled customers to build applications like game servers and status page monitors. Enhancements since early access include improved reliability and performance, jurisdictional restrictions, a cache in front of Durable Object storage, simplified uploads, and live debugging tools (`wrangler dev`, `wrangler tail`). Future work includes replication for multi-threaded access, guaranteed callbacks, and geo-distribution.
  16. Backwards-compatibility in Cloudflare WorkersIntroduced the concept of 'compatibility dates' for Cloudflare Workers. This allows for the introduction of backwards-incompatible changes to the Workers Runtime by providing developers with a mechanism to opt into future behaviors. Workers can be assigned a compatibility date, and the runtime will execute code based on that date, allowing for gradual rollout of breaking changes without impacting existing applications.
  17. Cloudflare Pages is Lightning FastThis post details how Cloudflare Pages leverages the global edge network and latest web standards (TLS 1.3, IPv6, QUIC/HTTP/3) for fast site delivery. It highlights performance comparisons via TTFB benchmarks against competitors and emphasizes the developer experience, including Git integration, fast builds, and built-in Web Analytics for Core Web Vitals. The post also mentions future integrations with Cloudflare Workers and monorepos.
  18. Cloudflare Workers: the Fast Serverless PlatformThis post provides updated performance benchmarks for Cloudflare Workers, demonstrating significant speed improvements (30% faster at P90 compared to three years ago, 210% faster than Lambda@Edge, and 298% faster than Lambda). It attributes these gains to the platform's edge-first architecture using V8 isolates, automatic benefit from network and protocol upgrades (like HTTP/3), and the elimination of cold starts. The post also emphasizes the developer experience benefits of fast global deployments (under a second) and the focus on end-user performance.
  19. Pin, Unpin, and why Rust needs themThis post explains the concepts of `Pin` and `Unpin` in Rust, which are crucial for safely implementing self-referential types, particularly within the context of `Future` implementations for asynchronous programming. It details why self-referential types can be unsafe due to memory movement and how `Pin` provides a mechanism to 'pin' values in memory, preventing them from being moved. The post uses the example of creating a `TimedWrapper` for async functions to illustrate the need for `Pin` when dealing with nested Futures and the `poll` method.
  20. Building the Cloudflare Summer Challenge ApplicationThis post details the technical implementation of the Cloudflare Summer Developer Challenge application, which was built using a Workers Site project. It highlights the use of Worktop for routing, the optimization of client pages by inlining CSS and JavaScript into HTML, and the integration of these static assets into a Worker using esbuild. The post also discusses the use of a templating syntax `{{ variable }}` for dynamic value injection during Worker requests and the development of a `render` utility function.
  21. Durable Objects: Easy, Fast, Correct — Choose threeThis post details significant improvements to Durable Objects, a feature of Cloudflare Workers. Previously, Durable Objects had subtle race conditions and performance issues due to the asynchronous nature of storage operations (get/put) and the need for data durability. The post explains how these issues were addressed by changing the Durable Objects runtime. The core change is that storage operations are now effectively serialized for a given object, preventing race conditions even with concurrent requests. This is achieved by ensuring that `put` operations are not returned until data is safely persisted, and by optimizing the `put` operation itself to be faster. The post also contrasts this with less ideal solutions like transactions (which add complexity and retry overhead) and in-memory caching (which previously had correctness issues). The new model allows developers to write code more intuitively, with correctness and performance improvements applied automatically.
  22. Announcing Green Compute on Cloudflare WorkersIntroduced 'Green Compute' for Cron-triggered Workers, allowing workloads to run exclusively on renewable energy-powered hardware. This feature leverages the existing global network's flexibility to route workloads without application changes, addressing sustainability goals for background jobs.
  23. Introducing Workers Usage NotificationsIntroduced Workers usage notifications, including a weekly summary of total request counts, duration, and egress data transfer, with breakouts for popular Workers showing median CPU time. Also introduced an on-demand 'Workers Usage Report' triggered when a Worker's CPU usage increases by more than 25% compared to its average over the previous seven days. These notifications are enabled by default for new free accounts and can be configured via the Cloudflare zone dashboard for email recipients, webhooks, or PagerDuty integration.
  24. Durable Objects, now in Open BetaThis post announces the open beta of Durable Objects, a new paradigm for stateful serverless computing on Cloudflare Workers. It details what Durable Objects are: providing coordination across multiple Workers and strongly consistent edge storage. Each Durable Object is defined by a JavaScript class and an ID, ensuring only one instance runs globally for a given ID. This allows for coordination across multiple requests and data access. The post also outlines pricing, comparing it favorably to AWS Lambda and DynamoDB, and highlights new features added since the initial announcement, such as jurisdictional restrictions and Wrangler support.
  25. Supporting Jurisdictional Restrictions for Durable ObjectsIntroduced Jurisdictional Restrictions for Durable Objects, allowing developers to specify a geographical region (e.g., 'eu') when generating a Durable Object ID. This ensures that the Durable Object only stores and processes data within the specified jurisdiction. This feature is implemented by encoding the jurisdiction into the Durable Object ID, which guides the Workers runtime to select a data center within that jurisdiction for object creation and maintenance. Currently, only the 'eu' jurisdiction is supported, with plans to add more based on demand. Jurisdictional Restrictions are not supported with user-generated IDs for Durable Objects.
  26. Workers Durable Objects Beta: A New Approach to Stateful ServerlessIntroduced Durable Objects, a new serverless primitive for managing state with strong consistency and enabling real-time coordination between clients on the edge. Durable Objects provide private, durable storage co-located with the object instance, and can act as coordination points for use cases like chat, collaborative editing, and game sessions. The post also announced the beta of Durable Objects and the addition of WebSocket support to Cloudflare Workers.
  27. Announcing wrangler dev — the Edge on localhostThis post announces the General Availability of `wrangler dev`, a new tool that provides an edge-based local development environment for Cloudflare Workers. It addresses the challenges of local development by offering a high-fidelity, consistent experience that mirrors production, including live reloading, direct terminal logging, and the ability to test features like Cache API and KV namespaces without impacting production data. This significantly improves the developer experience for building and testing Workers.
  28. Deploying security.txt: how Cloudflare’s security team builds on WorkersThis post details the use of Cloudflare Workers to host and manage the security.txt file. It highlights the benefits of using Workers for security projects, such as no server management, automatic security updates, and rapid deployment. The implementation involves using Wrangler CLI for deployment and version control, a Node.js script for dynamic expiration date generation, GPG for clearsigning the file at build time, and multi-route support in Wrangler to serve both security.txt and the PGP public key from a single Worker. The security.txt file itself is dynamically generated from a template.
  29. Workers Sites: Deploy Your Website Directly on our NetworkIntroduced Workers Sites, a new capability built on Cloudflare Workers and Workers KV, allowing developers to deploy entire static websites directly to Cloudflare's edge network. This eliminates the need for traditional origin servers and CDNs for static assets, simplifying deployment and improving performance by serving content from edge locations globally. The feature leverages Wrangler CLI for site upload and KV integration, automatically handling asset serving with appropriate headers.
  30. Live Preview: Build and Test Workers Faster with Wrangler CLI 1.2.0This post introduces a significant enhancement to the developer experience for Cloudflare Workers through the Wrangler CLI. Version 1.2.0 adds a 'live preview' and 'watch' functionality (`wrangler preview --watch`) that allows developers to see their changes reflected in a single browser tab automatically after saving files. This was achieved by implementing file system event monitoring with a cooldown period and using WebSockets for communication between the CLI and the previewer, greatly improving the speed and efficiency of the development and testing cycle for Workers.
  31. Building a GraphQL server on the edge with Cloudflare WorkersThis post introduces `workers-graphql-server`, an open-source Apollo GraphQL server specifically designed for Cloudflare Workers. It highlights how Workers' global distribution and low latency make them an ideal platform for hosting GraphQL servers, simplifying data management for full-stack developers and enabling rapid deployment of APIs worldwide.
  32. JAMstack podcast episode: Listen to Cloudflare's Kenton Varda speak about originless codeThis post introduces Cloudflare Workers, a serverless JavaScript execution environment at the edge. It explains the core functionality of intercepting and modifying HTTP requests, making outbound requests, and global deployment in under 30 seconds. Use cases like A/B testing, conditional routing, request filtering, response aggregation, and hotlink protection are detailed. The post also mentions the availability of code on GitHub and the community forum for feedback, along with Wrangler v2.0.
  33. Comparing Serverless Performance for CPU Bound TasksThis post benchmarks Cloudflare Workers against AWS Lambda and Lambda@Edge for CPU-bound tasks (PBKDF2 hashing) and prime factorization. It demonstrates that Workers are significantly faster and more cost-effective for these workloads, even when Lambda is configured with higher memory allocations or uses native code. The comparison highlights the performance advantages of Cloudflare's globally distributed edge network and its efficient CPU allocation for serverless functions.
  34. Cloudflare Workers is now on Open BetaThis post announces the open beta of Cloudflare Workers, a serverless JavaScript execution platform at the edge. It details the core capabilities: running code globally in 120+ data centers, intercepting/modifying requests, making outbound requests, and replacing CDN configurations. It provides a 'hello world' example and links to recipes for A/B testing, conditional routing, request filtering, response aggregation, and hotlink protection. It also mentions the availability of code examples on GitHub and a community forum for feedback.