Dynamic Workflows: Bringing Durable Execution to Every Tenant

By

When Cloudflare Workers launched eight years ago, the focus was on giving individual developers a direct path to serverless compute. Over time, that ecosystem evolved. Platforms started building on top of Workers—not just deploying their own apps, but enabling their customers to run custom code in multi-tenant environments. Today, the landscape includes applications where AI writes the implementation on the fly, multi-tenant SaaS platforms where each customer’s business logic is runtime TypeScript, agents that create and run their own tools, and CI/CD products where every repository defines its own pipeline.

The Journey from Static to Dynamic Deployment

The shift from static to dynamic deployment has been gradual but deliberate. Last month, the Dynamic Workers open beta gave platforms a clean compute primitive: hand the Workers runtime some code at runtime and get back an isolated, sandboxed Worker on the same machine in single-digit milliseconds. That solved the compute side of the multi-tenant puzzle.

Then came Durable Object Facets, which extended the same philosophy to storage. Each dynamically loaded application can have its own SQLite database, spun up on demand, with the platform acting as a supervisor. Artifacts did the same for source control—a Git-native, versioned filesystem that can be created by the tens of millions, one per agent, one per session, one per tenant. Together, they provided dynamic deployment for storage and source control.

The Missing Piece: Durable Execution for Dynamic Code

Cloudflare Workflows is our durable execution engine. It turns a run(event, step) function into a program where every step survives failures, can sleep for hours or days, can wait for external events, and resumes exactly where it left off when the isolate is recycled. It’s the right primitive for anything that has to “keep going” past a single request: onboarding flows, video transcoding pipelines, multi-stage billing, long-running agent loops. With Workflows V2, you get up to 50,000 concurrent instances and 300 new instances per second per account, redesigned for the agentic era.

But Workflows has always had one assumption baked in: the workflow code is part of your deployment. Your wrangler.jsonc has a block that says “when the engine calls into WORKFLOWS, run the class called MyWorkflow.” One binding, one class. Per deploy.

That works fine if you own all the code. It’s fine for a traditional application. But it stops working the moment you want to let your customer ship their own workflow.

Consider these scenarios:

• You’re building an app platform where AI writes TypeScript for every tenant.
• You’re running a CI/CD product where each repository has its own pipeline.
• You’re using an agent SDK where each agent writes its own durable plan.

In every case, the workflow is different for every tenant, every agent, every request. There is no single class to bind. This is the same shape of problem that Dynamic Workers solved for compute and that Durable Object Facets solved for storage.

Introducing Dynamic Workflows

Today, we are bridging durable execution and dynamic deployment with Dynamic Workflows. This new capability allows platforms to define workflow logic per tenant, per session, or per agent—without requiring a pre-deployed class binding.

With Dynamic Workflows, the workflow code can be provided at runtime, just like you do with Dynamic Workers. The runtime handles isolation, durability, and lifecycle management. The platform sits in front as a supervisor, ensuring each tenant’s workflow runs in its own sandboxed environment, with its own state and its own execution history.

What This Means for Platforms

For platform builders, Dynamic Workflows unlocks new possibilities:

• AI-generated workflows: Let the AI write the durable plan for each tenant.
• Multi-tenant CI/CD: Each repository defines its own pipeline as a workflow.
• Agent SDKs: Each agent can dynamically create and execute its own durable plan.
• Custom onboarding flows: Each customer gets a unique, stateful journey.

Just as Dynamic Workers gave you compute per tenant and Durable Object Facets gave you storage per tenant, Dynamic Workflows now gives you durable execution per tenant—all within the same isolated, sandboxed environment.

The Path Forward

Dynamic Workflows completes the triangle of dynamic deployment: compute, storage, and now durable execution. Platforms can build truly tenant-isolated applications where every customer’s logic—whether request-response or long-running—runs independently, scales automatically, and never shares a failure domain.

We’re excited to see what you build when every tenant can have its own durable workflow, defined at runtime, without a single class binding. This is the next step in making serverless truly multi-tenant at scale.

Related Articles

• 10 Critical Actions to Secure Your Software Supply Chain Today
• How Docker Hardened Images Rescue ClickHouse Deployments Blocked by Security Scanners
• Serverless Spam Detection API: Deploying a Scikit-Learn Model with AWS Lambda and API Gateway
• From Digital Clutter to Daily Ritual: Mastering Photo Decluttering with This Day
• Mastering Kubernetes Controller Health: New Staleness Solutions in v1.36
• The Day Germany's Internet Broke: Inside the .de DNSSEC Outage
• 10 Key Insights into Microsoft's Sovereign Private Cloud Scaling with Azure Local
• Cross-Account AI Safety: Amazon Bedrock Guardrails Centralizes Policy Enforcement