diff --git a/public/__redirects b/public/__redirects
index 64714d6b0bd4a9..fc7893aadeb9cd 100644
--- a/public/__redirects
+++ b/public/__redirects
@@ -2088,6 +2088,8 @@
/workers-ai/demos/* /workers-ai/guides/demos-architectures/:splat 301
/workers-ai/tutorials/* /workers-ai/guides/tutorials/:splat 301
+# Workflows
+/workflows/tutorials/ /workflows/examples 301
# Others
/logs/analytics-integrations/* /fundamentals/data-products/analytics-integrations/:splat 301
diff --git a/src/content/docs/learning-paths/workflows-course/series/index.mdx b/src/content/docs/learning-paths/workflows-course/series/index.mdx
new file mode 100644
index 00000000000000..0df7484bd14d08
--- /dev/null
+++ b/src/content/docs/learning-paths/workflows-course/series/index.mdx
@@ -0,0 +1,9 @@
+---
+pcx_content_type: navigation
+title: Overview
+sidebar:
+ order: 4
+ group:
+ hideIndex: true
+tableOfContents: false
+---
diff --git a/src/content/docs/learning-paths/workflows-course/series/workflows-1.mdx b/src/content/docs/learning-paths/workflows-course/series/workflows-1.mdx
new file mode 100644
index 00000000000000..fd8edd0168fe6a
--- /dev/null
+++ b/src/content/docs/learning-paths/workflows-course/series/workflows-1.mdx
@@ -0,0 +1,154 @@
+---
+pcx_content_type: navigation
+title: Introduction to Workflows
+sidebar:
+ order: 1
+tableOfContents: false
+description: |
+ Cloudflare Workflows provides durable execution capabilities, allowing developers to create reliable, repeatable workflows that run in the background. Workflows are designed to resume execution even if the underlying compute fails, ensuring that tasks complete eventually. They are built on top of Cloudflare Workers and handle scaling and provisioning automatically.
+---
+
+import { Render, Tabs, TabItem, Stream, Card } from "~/components";
+
+
+
+
+ Cloudflare Workflows provides durable execution capabilities, allowing developers to create reliable, repeatable workflows that run in the background. Workflows are designed to resume execution even if the underlying compute fails, ensuring that tasks complete eventually. They are built on top of Cloudflare Workers and handle scaling and provisioning automatically.
+
+ Workflows are triggered by events, such as Event Notifications consumed from a Queue, HTTP requests, another Worker, or even scheduled timers. Individual steps within a Workflow are designed as retriable units of work. The state is persisted between steps, allowing workflows to resume from the last successful step after failures. Workflows automatically generate metrics for each step, aiding in debugging and observability.
+
+
+
+
+ **Related content**
+
+ If you want to dive into detail, refer to the following pages:
+
+ - [Source code for the Punderful repository](https://github.com/craigsdennis/punderful-workflows)
+ - [Cloudflare Workflows](/workflows/)
+ - [Cloudflare Workers AI](/workers-ai/)
+
+
+
+
+
+
+ Punderful is a sample application that showcases the use of various Cloudflare primitives, including Workers, D1, Vectorize, Workers AI, and Workflows. The application displays a list of puns stored in a D1 database.
+
+ The homepage lists the latest puns stored in D1. The application also includes a semantic search feature powered by Vectorize. To perform a search:
+
+ 1. Go to the Punderful search page.
+ 2. Type a search query in the "Search for a pun..." input box.
+ 3. Observe the search results appearing instantly below the search box.
+
+ To demonstrate adding a new pun:
+
+ 1. Go to the Punderful creation page.
+ 2. Enter a new pun in the "Enter your pun here..." textarea.
+ 3. Observe the preview of the pun updating as you type.
+ 4. Click the "Submit Pun" button.
+
+ When a new pun is submitted, it needs to be indexed in Vectorize for the semantic search to work. This indexing process involves creating embeddings from the pun text. This is a task suitable for background processing using Cloudflare Workflows, avoiding delays for the user in the request-response loop.
+
+ ### Implementing a Workflow to Process New Puns
+
+ A workflow is implemented to handle the background processing required when a new pun is submitted.
+
+ #### Triggering the Workflow
+
+ When a new pun is submitted via the `/api/puns` endpoint, the data is first inserted into the D1 database. Then, a new Workflow instance is created and triggered to perform the subsequent background tasks.
+
+ [See here](https://github.com/craigsdennis/punderful-workflows/blob/7cec7f4bd7d6b17085cb6d6cb3e56b6a4b5b7c9d/src/index.tsx#L165)
+
+ In this handler, `c.env.PUBLISH.create(crypto.randomUUID(), { punId, pun: payload.pun })` creates a new instance of the workflow bound as `PUBLISH`, assigns it a unique ID, and passes the `punId` and `pun` text as the payload.
+
+ #### Defining the Workflow Class
+
+ The workflow logic is defined in a class that extends `WorkflowEntrypoint`.
+
+ [See here](https://github.com/craigsdennis/punderful-workflows/blob/7cec7f4bd7d6b17085cb6d6cb3e56b6a4b5b7c9d/src/workflows/publish.ts#L12)
+
+ The `run` method is the entrypoint for the workflow execution. It receives the `event` containing the payload and a `step` object to define individual, durable steps.
+
+ #### Workflow Steps
+
+ Each discrete, retriable task in the workflow is defined using `await step.do()`.
+
+ ##### Content Moderation
+
+ Optionally, the workflow can perform content moderation using an external service like OpenAI's moderation API if an API key is available in the environment.
+
+ [See here](https://github.com/craigsdennis/punderful-workflows/blob/7cec7f4bd7d6b17085cb6d6cb3e56b6a4b5b7c9d/src/workflows/publish.ts#L16)
+
+ This step calls the OpenAI moderation API. If the content is flagged as inappropriate, the pun's status is updated in the database, and a `NonRetryableError` is thrown. Throwing a `NonRetryableError` prevents the workflow from retrying this step, as the content is permanently deemed inappropriate.
+
+ ##### Creating Embeddings
+
+ Next, create vector embeddings for the pun text using a Workers AI model.
+
+[See here](https://github.com/craigsdennis/punderful-workflows/blob/7cec7f4bd7d6b17085cb6d6cb3e56b6a4b5b7c9d/src/workflows/publish.ts#L34)
+
+ This step uses the `@cf/baai/bge-large-en-v1.5` model from Workers AI to generate a vector embedding for the `pun` text. The result (the embedding vector) is returned by the step and can be used in subsequent steps. `step.do()` ensures this step will be retried if it fails, guaranteeing that embeddings are eventually created.
+
+ ##### Categorizing the Pun
+
+ Optionally, use a Workers AI language model to categorize the pun.
+
+ [See here](https://github.com/craigsdennis/punderful-workflows/blob/7cec7f4bd7d6b17085cb6d6cb3e56b6a4b5b7c9d/src/workflows/publish.ts#L41)
+
+ This step uses the `@cf/meta/llama-3.1-8b-instruct` model with a specific system prompt to generate categories for the pun. The generated categories string is returned by the step. This step also benefits from `step.do()`'s reliability.
+
+ ##### Adding Embeddings to Vectorize
+
+ Insert the created pun embedding and potentially categories embedding into the Vectorize database.
+
+ [See here](https://github.com/craigsdennis/punderful-workflows/blob/7cec7f4bd7d6b17085cb6d6cb3e56b6a4b5b7c9d/src/workflows/publish.ts#L78)
+
+ This step uses `this.env.VECTORIZE.upsert()` to add the generated embeddings and associated metadata to the Vectorize database. This makes the pun searchable semantically. `step.do()` ensures this critical indexing step is completed reliably.
+
+ ##### Updating Database Status
+
+ The final step updates the status of the pun in the D1 database to indicate that it has been published and processed by the workflow.
+
+ [See here](https://github.com/craigsdennis/punderful-workflows/blob/7cec7f4bd7d6b17085cb6d6cb3e56b6a4b5b7c9d/src/workflows/publish.ts#L104)
+
+ This step updates the `status` column in the D1 database to "published" for the corresponding pun ID. Once this step is complete, the pun is considered fully processed and ready to be displayed on the homepage.
+
+ #### Workflow Bindings
+
+ To make the `PublishWorkflow` class available to the main Worker and to provide access to necessary resources (like D1, AI, Vectorize), bindings are configured in the `wrangler.toml` file.
+
+ [See here](https://github.com/craigsdennis/punderful-workflows/blob/main/wrangler.toml)
+
+ This configuration defines a workflow named `publish`, binds it to the environment variable `PUBLISH`, and links it to the `PublishWorkflow` class in `src/index.ts`. It also shows bindings for Workers AI (`AI`) and Vectorize (`VECTORIZE`), which are accessed via `this.env` within the workflow.
+
+ ### Vectorize for Semantic Search
+
+ Vectorize is a vector database used in this application to enable semantic search for puns. It stores the vector embeddings created by Workers AI. The search functionality queries this Vectorize index to find puns similar in meaning to the user's query.
+
+ The homepage displays recently published puns (status "published"). The detail page for a specific pun displays "Similar Puns", which are found by querying Vectorize with the embedding of the current pun.
+
+ ### Scalability
+
+ Cloudflare Workers and Workflows are designed to scale automatically based on demand, handling concurrent requests and background tasks efficiently without requiring manual provisioning.
+
+
+
+
+
+
+
diff --git a/src/content/docs/learning-paths/workflows-course/series/workflows-2.mdx b/src/content/docs/learning-paths/workflows-course/series/workflows-2.mdx
new file mode 100644
index 00000000000000..53fc9e50c0aef6
--- /dev/null
+++ b/src/content/docs/learning-paths/workflows-course/series/workflows-2.mdx
@@ -0,0 +1,137 @@
+---
+pcx_content_type: navigation
+title: Monitor and batch your website data
+sidebar:
+ order: 2
+tableOfContents: false
+description: |
+ Workflows can be used to process batches of data, ensuring each item in the batch goes through a defined process with reliable execution. This section demonstrates processing a batch of puns using the Punderful application as an example.
+
+---
+
+import { Render, Tabs, TabItem, Stream, Card } from "~/components";
+
+
+
+
+ Workflows can be used to process batches of data, ensuring each item in the batch goes through a defined process with reliable execution. This section demonstrates processing a batch of puns using the Punderful application as an example.
+
+
+
+
+ **Related content**
+
+ If you want to dive into detail, refer to the following pages:
+
+ - [Source code for the Punderful repository](https://github.com/craigsdennis/punderful-workflows)
+ - [Cloudflare Workflows](/workflows/)
+ - [Cloudflare Workers AI](/workers-ai/)
+
+
+
+
+
+
+ The Punderful application processes user-submitted puns by performing content moderation, creating embeddings, categorizing, and adding them to a vector store. This process is defined as a Workflow. To process a batch of existing puns (from an open-source dataset called OPun), a batch endpoint is created that iterates through the puns and triggers the defined Workflow for each one.
+
+ #### Batch Processing Code
+
+ The following code snippet shows the endpoint responsible for batch processing:
+
+ [See here](https://github.com/craigsdennis/punderful-workflows/tree/main/src/index.tsx#L291)
+
+ This code:
+
+ 1. Fetches the list of puns from a JSON file (`puns.json`).
+ 2. Logs the number of puns being processed.
+ 3. Sets a user ID for tracking.
+ 4. Loops through each pun.
+ 5. Performs basic text cleaning on the pun.
+ 6. Inserts the pun into the database (handled by `insertPun`).
+ 7. Triggers the `PUBLISH` Workflow for each individual pun using `c.env.PUBLISH.create()`. The Workflow is given a unique ID using `crypto.randomUUID()`.
+
+ ### Monitoring Workflow Instances via CLI
+
+ The Cloudflare Wrangler CLI provides commands to monitor and manage Workflows and their instances.
+
+ To list the available workflows associated with your account:
+
+ ```bash
+ npx wrangler workflows list
+ ```
+
+ To list the instances of a specific workflow (for example, the `publish` workflow):
+
+ ```bash
+ npx wrangler workflows instances list publish
+ ```
+
+ This command will show a list of workflow instances, their status (Queued, Running, Completed, Errored), and timestamps.
+
+ To view the details of a specific workflow instance, including its steps and their status, duration, and output:
+
+ ```bash
+ npx wrangler workflows instances describe publish
+ ```
+
+ Replace `` with the actual ID of a running or completed instance from the `list` command output.
+
+ #### Example CLI Output (Describe Instance)
+
+ Describing a workflow instance provides a detailed breakdown of its execution:
+
+ ```
+ Workflow Name: publish
+ Instance ID: oPun-batch-aea07d75-95fa-448f-9573-6e435388eff7
+ Version ID: 75665fce-24a1-4c83-a561-088aabc91e5f
+ Status: Completed
+ Trigger: API
+ Queued: 10/24/2024, 1:43:45 AM
+ Success: Yes
+ Start: 10/24/2024, 1:43:45 AM
+ End: 10/24/2024, 1:43:49 AM
+ Duration: 4 seconds
+ Last Successful Step: update-status-to-published-1
+ Steps:
+
+ Name: content-moderation-1
+ Type: Step
+ Start: 10/24/2024, 1:43:45 AM
+ End: 10/24/2024, 1:43:45 AM
+ Duration: 0 seconds
+ Success: Yes
+ Output: "true"
+ Config: {"retries":{"limit":5,"delay":1000,"backoff":"exponential"},"timeout":"10 minutes"}
+ Attempts:
+ Status: Completed
+ Start Time: Oct 23, 2024 6:44:57 PM
+ End Time: Oct 23, 2024 6:44:57 PM
+ Wall Time: 180 ms
+ ... (additional steps like create-pun-embedding-1, categorize-pun-1, add-embeddings-to-vector-store-1, update-status-to-published-1)
+ ```
+
+ This output shows the status, start/end times, duration, success status, and even the output and configuration for each step within the workflow instance.
+
+ ### Monitoring Workflow Instances via Cloudflare Dashboard
+
+ You can also monitor Workflows and their instances directly in the Cloudflare Dashboard.
+
+ This dashboard view provides a user-friendly way to observe the progress of your batch jobs, identify failed instances, and inspect the execution details of each step.
+
+
+
+
+
+
+
diff --git a/src/content/docs/learning-paths/workflows-course/series/workflows-3.mdx b/src/content/docs/learning-paths/workflows-course/series/workflows-3.mdx
new file mode 100644
index 00000000000000..61502ad0ecd573
--- /dev/null
+++ b/src/content/docs/learning-paths/workflows-course/series/workflows-3.mdx
@@ -0,0 +1,148 @@
+---
+pcx_content_type: navigation
+title: Use cron triggers to develop time-aware applications
+sidebar:
+ order: 3
+tableOfContents: false
+description: |
+ Cloudflare Workflows provide a powerful way to manage asynchronous, durable processes. The ability to explicitly schedule tasks using cron triggers and pause execution with `step.sleep` allows developers to build sophisticated, time-aware applications.
+---
+
+import { Render, Tabs, TabItem, Stream, Card } from "~/components";
+
+
+
+
+ Cloudflare Workflows provide a powerful way to manage asynchronous, durable processes. The ability to explicitly schedule tasks using cron triggers and pause execution with `step.sleep` allows developers to build sophisticated, time-aware applications.
+
+
+
+
+ **Related content**
+
+ If you want to dive into detail, refer to the following pages:
+
+ - [Source code for the Punderful repository](https://github.com/craigsdennis/punderful-workflows)
+ - [Cloudflare Workflows](/workflows/)
+ - [Cloudflare Workers AI](/workers-ai/)
+
+
+
+
+
+
+ Workflows allow you to kick off asynchronous processes without blocking the user. This is demonstrated in the `addInteraction` function, which creates a new instance of the `INTERACTION` workflow.
+
+ Locate the `addInteraction` function in `src/index.tsx`:
+
+ [See here](https://github.com/craigsdennis/punderful-workflows/blob/main/src/index.tsx#L237)
+
+ This function is called when a user interacts with a pun (for example, likes it). Instead of performing the interaction logic directly, it offloads the work to a workflow.
+
+ Examine the `InteractionWorkflow` definition in `src/workflows/interaction.ts`. This workflow performs tasks like checking if the user/session exists and recording the interaction in the database.
+
+ [See here](https://github.com/craigsdennis/punderful-workflows/blob/main/src/workflows/interaction.ts)
+
+ ### Leaderboard Code
+
+ A common use case for background processes is crunching data and caching results, such as building a leaderboard.
+
+ Examine the `LeaderboardWorkflow` in `src/workflows/leaderboard.ts`. This workflow performs a database query to find trending puns and then stores the results in Cloudflare KV (Key-Value Store).
+
+ [See here](https://github.com/craigsdennis/punderful-workflows/blob/main/src/workflows/leaderboard.ts)
+
+ This workflow can be scheduled to run periodically to update the leaderboard data.
+
+ ### Wrangler.toml Configuration
+
+ The `wrangler.toml` file is used to configure your Worker and Workflows. This includes defining bindings to resources like KV namespaces and setting up triggers for workflows.
+
+ Open `wrangler.toml` and find the `[triggers]` section.
+
+ [See here](https://github.com/craigsdennis/punderful-workflows/blob/main/wrangler.toml#L68)
+
+ The `crons` array allows you to define scheduled triggers for your main Worker. The example shows a cron job configured to run every 30 minutes.
+
+ Locate the `scheduled` handler in your main Worker code (`src/index.tsx`). This handler is executed when a cron trigger fires.
+
+ [See here](https://github.com/craigsdennis/punderful-workflows/blob/main/src/index.tsx#L315)
+
+ This handler creates an instance of the `LEADERBOARD_WORKFLOW`, initiating the leaderboard update process on a schedule.
+
+ ### Puntificator: Using AI to Develop More Puns Automatically
+
+ Workflows can also be used for more complex, multi-step processes, including interacting with AI models. The `PuntificatorWorkflow` is an example that leverages AI to generate and evaluate new puns.
+
+ Examine the `PuntificatorWorkflow` definition in `src/workflows/puntificator.ts`.
+
+ [See here](https://github.com/craigsdennis/punderful-workflows/blob/main/src/workflows/puntificator.ts)
+
+ This workflow includes steps to:
+
+ 1. Retrieve trending puns.
+ 2. Create a new pun based on trends using an AI model.
+ 3. Judge the quality of the created pun using another AI model.
+ 4. Save the pun if it meets a certain rating threshold.
+
+ Crucially, this workflow includes a `step.sleep` call:
+
+ [See here](https://github.com/craigsdennis/punderful-workflows/blob/main/src/workflows/puntificator.ts#L135)
+
+ This step pauses the workflow execution for a specified duration. This is useful for waiting to consider user feedback on a published pun before potentially taking further action based on its popularity.
+
+ ### Nested Workflows
+
+ Workflows can initiate other workflows, allowing you to compose complex processes from smaller, modular units.
+
+ In the `PuntificatorWorkflow`, find where it calls the `PUBLISH` workflow.
+
+ [See here](https://github.com/craigsdennis/punderful-workflows/blob/main/src/workflows/puntificator.ts#L115)
+
+ This demonstrates how one workflow can trigger another, enabling the separation of concerns and modular design.
+
+ Examine the `PublishWorkflow` in `src/workflows/publish.ts`.
+
+ [See here](https://github.com/craigsdennis/punderful-workflows/blob/main/src/workflows/publish.ts)
+
+ This workflow handles the logic for publishing a pun, likely involving saving it to the database and making it visible on the site.
+
+ ### Workflow Instances
+
+ You can trigger workflows manually and inspect their execution status and output using the `wrangler` command-line tool.
+
+ To trigger the `PuntificatorWorkflow` manually:
+
+ ```bash
+ npx wrangler workflows trigger puntificator
+ ```
+
+ This command will queue an instance of the workflow. You will receive a success message and the instance ID.
+
+ To describe the latest instance of a workflow:
+
+ ```bash
+ npx wrangler workflows instances describe puntificator latest
+ ```
+
+ This command will show details about the most recent run of the specified workflow, including its start time, end time, duration, state, and the state of each individual step within the workflow. You can observe steps like `create-new-pun-based-on-trends`, `judge-pun`, `save-pun`, `publish`, and `wait-for-publish` (which shows a 'Sleeping' state).
+
+
+
+
+
+
diff --git a/src/content/docs/workflows/tutorials/index.mdx b/src/content/docs/workflows/tutorials/index.mdx
deleted file mode 100644
index cfb7e3e63ae071..00000000000000
--- a/src/content/docs/workflows/tutorials/index.mdx
+++ /dev/null
@@ -1,14 +0,0 @@
----
-type: overview
-hideChildren: true
-pcx_content_type: navigation
-title: Tutorials
-sidebar:
- order: 4
----
-
-import { GlossaryTooltip, YouTubeVideos } from "~/components";
-
-View tutorials to help you get started with Workers.
-
-
diff --git a/src/content/docs/workflows/videos.mdx b/src/content/docs/workflows/videos.mdx
new file mode 100644
index 00000000000000..ed867207b957cc
--- /dev/null
+++ b/src/content/docs/workflows/videos.mdx
@@ -0,0 +1,16 @@
+---
+pcx_content_type: navigation
+title: Videos
+sidebar:
+ order: 5
+---
+
+import { CardGrid, LinkCard } from "~/components";
+
+
+
+
diff --git a/src/content/learning-paths/workflows-course.json b/src/content/learning-paths/workflows-course.json
new file mode 100644
index 00000000000000..08c206e841fb6c
--- /dev/null
+++ b/src/content/learning-paths/workflows-course.json
@@ -0,0 +1,9 @@
+{
+ "title": "Introduction to Cloudflare Workflows",
+ "path": "/learning-paths/workflows-course/series/workflows-1/",
+ "priority": 2,
+ "description": "In this series, we introduce Cloudflare Workflows and the term 'Durable Execution' which comes from the desire to run applications that can resume execution from where they left off, even if the underlying host or compute fails.",
+ "products": ["Durable Objects", "Workers"],
+ "product_group": "Developer platform",
+ "video": true
+}
diff --git a/src/content/partials/learning-paths/workflows-series-navigation.mdx b/src/content/partials/learning-paths/workflows-series-navigation.mdx
new file mode 100644
index 00000000000000..3aef6a36002ba8
--- /dev/null
+++ b/src/content/partials/learning-paths/workflows-series-navigation.mdx
@@ -0,0 +1,24 @@
+---
+{}
+
+---
+
+import { CardGrid, LinkCard, Card } from "~/components";
+
+
+
+
+
+