# Connections
Source: https://workflowmachine.mintlify.app/concepts/connections
Learn what connections are, why they are separate from workflows, and how they make app integrations reusable.
## What a connection is
A connection is the saved authentication that lets Workflow Machine access an external app on your behalf through the [Connections](https://app.workflowmachine.com/connections) page.
Instead of re-entering credentials inside every workflow, you create a connection once and select it wherever a step needs that app.
## Why connections are separate from workflows
Connections are managed separately so they can be reused.
That gives you a few important benefits:
* you do not repeat authentication work in every workflow
* you can update a connection without redesigning the workflow
* several workflows can use the same connected account
This separation makes workflows easier to build and easier to maintain over time.
## What connections are used for
Connections are commonly needed when a workflow step:
* reads data from an app
* writes data to an app
* creates records, messages, or documents
* listens for app-native events
Examples include connecting Slack, Gmail, Notion, Google Sheets, Stripe, Outlook, Dropbox, or Telegram.
## What can go wrong with a connection
Even when a workflow is designed correctly, a step can still fail if the connection is not valid.
Common causes:
* the wrong account is connected
* required permissions were not granted
* a token expired
* the step is pointing to a different connection than expected
When a workflow fails unexpectedly, checking the connection is often one of the fastest ways to narrow down the issue.
## Good connection hygiene
As you build more workflows, it helps to:
* name connections clearly
* reuse connections when appropriate
* avoid duplicate connections unless separate accounts are needed
* review old or broken connections periodically
Good connection management reduces confusion later, especially when more than one workflow depends on the same external app.
## How to think about connections
If a workflow is the process, the connection is the permission that lets the process act in another system.
That is why connections are such an important concept even though they sit outside the workflow editor itself.
# Credits and usage
Source: https://workflowmachine.mintlify.app/concepts/credits-and-usage
Understand run credits, AI credits, and how usage affects the workflows you build.
## Why usage matters
Workflow Machine tracks usage so you can understand how much automation work your workspace is consuming over time.
This is useful for planning, troubleshooting, and keeping important workflows within the limits of your current [Subscription](https://app.workflowmachine.com/settings/subscription) plan.
## Two kinds of usage to watch
The two main usage categories are:
* **Run credits**
* **AI credits**
These measure different parts of workflow activity.
## Run credits
Run credits reflect workflow execution volume.
In the current product model, every 10 workflow steps count as 1 run credit. That means a longer workflow can consume more credits than a shorter one, even if both are triggered the same number of times.
Examples:
* 1 step = 1 run credit
* 10 steps = 1 run credit
* 11 steps = 2 run credits
This is worth keeping in mind when designing workflows with:
* many repeated steps
* unnecessary branching
* extra processing that does not change the outcome
Simple workflows are not just easier to maintain. They are usually more efficient too.
## AI credits
AI credits track the parts of the product that rely on AI generation or processing.
If your workflows use AI steps for summarization, extraction, drafting, or classification, those workflows will usually affect AI credit usage in addition to run credits. All chat messages also count toward AI credit usage.
If you use your own AI connections with providers such as OpenAI, Anthropic, or Gemini, AI credits are not consumed for that provider usage because the model calls are billed through your own API key instead.
The more often an AI step runs, the more important it becomes to monitor usage and make sure the step is actually adding value.
## How to design with usage in mind
You do not need to optimize every workflow immediately, but a few habits help:
* keep your first version small
* avoid unnecessary steps
* use AI only where it improves the result
* test before publishing so failed runs do not waste repeated execution
* review run history to spot workflows that trigger too often
Usage awareness is not about making workflows minimal at all costs. It is about making them intentional.
## Where to check usage
Usage information is available in the product [Subscription](https://app.workflowmachine.com/settings/subscription) page.
That is where you can review how many run credits and AI credits have been used relative to your plan.
If a workflow is running more often than expected, usage data is one of the fastest ways to notice it.
## A practical way to think about credits
Use this mental model:
* **Run credits** measure how much workflow execution is happening
* **AI credits** measure how much AI work is happening inside those workflows
If a workflow becomes expensive in either category, it is often a sign that the trigger frequency, step count, or AI usage pattern should be reviewed.
# Runs
Source: https://workflowmachine.mintlify.app/concepts/runs
Understand what a workflow run is, what run states mean, and how runs help you monitor and troubleshoot automations.
## What a run is
A run is one execution of a workflow.
Every time the workflow starts from a trigger, Workflow Machine creates a run. That run records what happened as the workflow moved through its steps.
Runs are how you answer questions like:
* did the workflow start
* which step failed
* what output did a step produce
* did the workflow complete successfully
## Why runs matter
Building a workflow is only half the job. The other half is understanding how it behaves over time.
Runs give you that visibility. They help you:
* confirm the workflow is working
* debug failures
* inspect data passed between steps
* understand how real inputs differ from test inputs
Without run history, automation becomes much harder to trust.
## Common run states
The most important run outcomes are:
* **Started**
* **Completed**
* **Failed**
* **Stopped**
* **Timeout**
In practice:
* **Completed** means the workflow reached the end successfully
* **Failed** means one of the steps or conditions caused the run to break
* **Stopped** means execution was intentionally halted
* **Timeout** means the run took too long to finish
These states help you decide whether the next action is “leave it alone,” “fix configuration,” or “redesign the workflow.”
## Runs are also a debugging tool
When something goes wrong, start with the run.
Review:
* the trigger input
* the step sequence
* the first step that failed
* the outputs produced before the failure
This is usually more useful than changing the workflow immediately, because the run shows what actually happened.
## Test runs and real runs
Both are valuable, but they serve different purposes.
* **Test runs** help you validate setup before going live
* **Real runs** show how the workflow behaves with real inputs and timing
Many workflows pass a test and still reveal edge cases later. That is normal. The important thing is that runs give you a place to inspect and improve.
## A healthy workflow habit
After publishing any important workflow, review the first few real runs.
That habit helps you catch:
* unexpected input formats
* missing fields
* auth problems
* logic branches that do not behave the way you intended
Over time, run history becomes one of the most useful parts of the product.
# Steps
Source: https://workflowmachine.mintlify.app/concepts/steps
Understand what steps do inside a workflow and how to combine actions, AI, and logic in sequence.
## What a step is
A step is a unit of work inside a workflow.
After the trigger starts the workflow, each step performs a task. Some steps talk to apps, some transform or inspect data, some use AI, and some control the flow of the workflow itself.
## Different kinds of steps
Workflow Machine supports several common step patterns.
### App action steps
These steps interact with external services.
Examples include:
* sending a message
* creating a page or record
* writing to a spreadsheet
* making an HTTP request
These are often the steps that produce the final user-visible outcome.
### AI steps
AI steps are useful when the workflow needs to work with text or unstructured information.
Common uses include:
* summarization
* extraction
* classification
* drafting
* rewriting
AI works best when the step has a clear job and the expected output is easy to evaluate.
### Control-flow steps
Some steps exist to shape the workflow rather than talk to an app.
Common examples include:
* **If** to branch based on conditions
* **Wait** to pause before continuing
* **End** to stop the workflow early
* state-related steps for reading or setting workflow state
These steps help make the workflow more predictable and efficient.
## Why step order matters
Steps run in sequence, so the output of one step often becomes the input to the next.
That means the order of steps changes the behavior of the workflow. For example:
* summarize first, then notify
* fetch data first, then decide
* check a condition first, then continue only if it passes
Good workflow design usually comes down to putting the right steps in the right order.
## What makes a good step
A good step has:
* one clear job
* only the fields it actually needs
* an output that is useful to the next step
If a step is trying to do too much, the workflow becomes harder to test and troubleshoot.
## A practical design habit
When adding a new step, ask:
* what input does this step need
* what output should it produce
* who or what uses that output next
Those three questions prevent a lot of messy workflow design.
## Start simple
The easiest workflows to maintain are usually made of small, understandable steps. It is better to have a short sequence of clear steps than one confusing chain where the logic is hard to explain.
# Templates
Source: https://workflowmachine.mintlify.app/concepts/templates
Learn what workflow templates are, how they help you move faster, and when to use them instead of starting from scratch.
## What a template is
A template is a reusable starting point for a workflow. You can browse available options in the [Templates](https://app.workflowmachine.com/templates) page.
Instead of building from a blank editor, you can begin with a prepared structure that already includes a use case, a trigger pattern, or a step sequence.
## Why templates are useful
Templates help in two main ways:
* they save setup time
* they show you how a workflow can be structured
That makes them useful both for new users and for experienced users who want to launch common automations faster.
## What templates are good for
Templates are especially helpful when:
* you want to automate a common business workflow
* you need a fast starting point
* you want to learn from a working example
* you are not sure how to structure the trigger and step sequence yet
Examples include notifications, summaries, lead routing, spreadsheet logging, and content workflows.
## What templates do not replace
A template is still a starting point, not a finished deployment.
You usually still need to:
* connect your own app accounts
* choose the right destinations
* update prompts or field mappings
* test before publishing
In other words, templates reduce setup work, but they do not remove the need for review.
## When to use a template
Use a template when speed matters more than starting from a blank page.
Templates are a strong choice when:
* the workflow pattern is common
* you want to avoid repetitive setup
* the use case already resembles something the template covers
## When to start from scratch
Start from scratch when:
* your process is highly specific
* you want to learn every part of the workflow directly
* the available templates are more complex than your actual need
There is no wrong choice here. Templates are just one way to begin.
## A good way to use templates
The best workflow habit is:
1. choose the closest matching template
2. simplify it if needed
3. connect your own apps
4. run a test
5. publish only after you understand the flow
That keeps templates useful without turning them into black boxes.
# Triggers
Source: https://workflowmachine.mintlify.app/concepts/triggers
Learn what triggers are, what kinds of triggers Workflow Machine supports, and how to choose the right one.
## What a trigger is
A trigger is what starts a workflow.
Without a trigger, a workflow has nothing to react to. The trigger defines the real-world event or schedule that causes the automation to begin.
## Common trigger types
Workflow Machine supports several useful trigger patterns.
### Webhook triggers
Webhook triggers start a workflow when another system sends data into Workflow Machine.
Use a webhook when:
* another tool can send HTTP requests
* you want to start the workflow from a custom system
* you need direct control over the input payload
Webhook triggers are flexible and often a strong first choice for integrations that do not have a native trigger.
### Schedule triggers
Schedule triggers run a workflow at a time or interval you define.
Use a schedule when:
* the workflow should run repeatedly
* the workflow is based on time rather than an external event
* you want a recurring digest, sync, or cleanup process
Examples include daily summaries, periodic checks, and timed reminders.
### RSS triggers
RSS triggers monitor feed updates and start a workflow when new content appears.
Use an RSS trigger when:
* you want to monitor blogs, news sources, or other feed-based content
* you want to collect or summarize updates on a recurring basis
### App event triggers
Some connected apps provide native events that can start workflows.
Use an app trigger when:
* the integration already exposes the event you need
* you want less custom setup than a webhook
* you want the workflow to start closer to the source app itself
## How to choose the right trigger
Pick the trigger that matches the natural starting point of the process.
A simple decision guide:
* choose **Webhook** when another system sends data to you
* choose **Schedule** when time is the main driver
* choose **RSS** when feed updates are the source
* choose an **App event** when the integration already supports it
If you choose the wrong trigger model, the workflow can become harder to maintain than it needs to be.
## What makes a good trigger
A good trigger is:
* easy to explain
* easy to test
* closely tied to the real event you care about
For example, “new form response” is a better trigger idea than “run every minute and check whether a form changed,” unless a schedule is the only option available.
## Trigger design tips
When planning a workflow, ask:
* what exact event should start this process
* how often should it happen
* what data will the trigger provide
* is this input stable enough for downstream steps
Those questions usually surface the right trigger choice quickly.
# Workflows
Source: https://workflowmachine.mintlify.app/concepts/workflows
Understand what a workflow is in Workflow Machine and how triggers, steps, runs, and versions fit together.
## What a workflow is
A workflow is an automation that starts with a trigger and completes a sequence of steps.
In Workflow Machine, a workflow is the main unit of work you build, test, publish, and monitor. It is the container that brings together:
* the event that starts the automation
* the steps that process data or take action
* the connections that let steps talk to external apps
* the runs that show what happened over time
## The basic workflow model
Most workflows follow the same structure:
1. A trigger starts the workflow.
2. One or more steps process the input.
3. The workflow creates an output, update, notification, or downstream action.
That structure can be simple or complex, but the core model stays the same.
## A workflow can have multiple triggers
Some workflows use more than one trigger.
These triggers are independent from each other. Each trigger can start the workflow on its own and send data into the same sequence of workflow steps without affecting the other triggers.
This is useful when you want the same workflow logic to run from multiple sources. For example, you might want the same follow-up process to start from a webhook, a schedule, or an app event without rebuilding the whole workflow each time.
## What makes up a workflow
The most important parts of a workflow are:
* **Trigger**: the event that starts the workflow
* **Steps**: the actions and logic that happen after the trigger
* **Connections**: the authenticated app accounts the steps can use
* **Runs**: the execution records created when the workflow actually runs
* **Versions**: saved changes over time, especially around publishing
If you understand those five concepts, you understand most of the product.
## Workflows are designed to be tested
A workflow is not just a diagram. It is something you can test before making it live.
That matters because most automation issues come from:
* trigger setup
* missing or invalid connections
* incorrect field mapping
* assumptions about the shape of incoming data
Workflow Machine is structured to help you catch those issues before they affect real work.
## Workflows are designed to be reused and improved
You do not need to build the perfect workflow immediately.
A common pattern is:
1. Start with one trigger and one outcome.
2. Confirm a successful run.
3. Add more logic, branching, and integrations later.
That is usually a better path than trying to design an advanced workflow before you have seen any real runs.
## A good way to think about workflows
If you are new to the product, think of a workflow as:
* one process
* with one starting event
* and one repeatable way of handling that event
Once you think in those terms, it becomes much easier to decide what belongs in a workflow and what should be a separate automation.
# Connection troubleshooting
Source: https://workflowmachine.mintlify.app/connections/connection-troubleshooting
Troubleshoot invalid, expired, or misconfigured connections when workflow steps stop working.
## Start with the connection
When a workflow step fails against an external app, the connection is one of the first things to check.
Even if the workflow logic is correct, a bad connection can still cause the run to fail.
## Most common connection problems
The most common causes are:
* the wrong account is connected
* the step is using the wrong saved connection
* the connection no longer has the required permissions
* the token or credentials have become invalid
* the account credentials, such as the password, were changed and the token was revoked
* a default connection was selected when a different account was intended
These issues are much more common than a broken integration in the abstract.
## Signs that the connection may be the problem
Look at the failing step and ask:
* did this workflow used to work before
* does the failure mention auth, access, or invalid credentials
* is the selected app account still correct
* did someone change permissions or rotate credentials recently
* did the account password or other credentials change recently
If the answer to any of these is yes, the connection is a strong suspect.
## A practical debugging order
Use this sequence:
1. Confirm which connection the failing step is using.
2. Confirm that the connection belongs to the intended account.
3. Check whether the account still has the right permissions.
4. Reauthenticate or replace the connection if it appears invalid.
5. Run a test again before changing workflow logic.
This order helps avoid unnecessary workflow edits when the real issue is simply app access.
## Check for invalid state
Workflow Machine can surface when a saved connection is invalid.
If you see a connection marked invalid, treat that as a strong signal that the problem is with the app access itself rather than the workflow design.
In that case, the best next step is usually to reconnect, refresh, or replace the connection and then rerun the workflow test.
## When the wrong account is the problem
Sometimes the connection is technically valid, but it is still wrong for the workflow.
Examples:
* a personal Slack workspace instead of the company one
* a test Notion workspace instead of production
* an old Gmail account instead of the current inbox
This is why account verification matters just as much as authentication success.
## When permissions are the problem
A connection may succeed during setup but still fail during execution if the account lacks the permissions needed for a specific step.
For example, the workflow might be able to sign in but not:
* post to the target channel
* edit the destination page
* create the requested record
* access the document or database you selected
If a step fails only for certain targets, permissions are often the cause.
## After you fix the connection
Once you update or replace a connection:
* rerun a test
* verify the specific failing step
* trigger one real run if the workflow is important
That confirms the problem is actually resolved and not just temporarily masked.
## Keep troubleshooting focused
When a workflow fails, it is tempting to edit several things at once. Try not to.
If the real problem is the connection, changing workflow logic at the same time makes debugging slower. Fix access first, retest, then move on only if the issue remains.
# Create a connection
Source: https://workflowmachine.mintlify.app/connections/create-a-connection
Create your first app connection in Workflow Machine and make it available to your workflows.
## Before you create a connection
Pick the app you want to use in a workflow first.
Good first connection choices are usually apps where you can verify the result quickly, such as:
* Slack
* Google Sheets
* Notion
* Gmail
These are easier to validate because the outcome of a workflow step is visible right away.
## Step 1: Open Connections
Go to [**Connections**](https://app.workflowmachine.com/connections) in Workflow Machine.
This is the central place for managing the app accounts your workflows rely on.
## Step 2: Choose the app
Create a new connection for the app you want to use.
Different apps may ask for different authentication details. In practice, this usually means one of:
* signing in through OAuth
* entering an API key or token
* completing an app-specific connection flow
Use the account that matches the workflow you actually intend to run. Choosing the wrong account is one of the easiest ways to create confusion later.
## Step 3: Complete authentication
Finish the required sign-in or credential entry flow, then save the connection.
After saving, confirm that the connection appears in your connections. At that point it should be available for supported workflow steps that use that app.
## Step 4: Check the connection details
Before you move on, confirm:
* the connection is for the correct app
* the account is the one you intended to use
* any required permissions were granted
If the app supports multiple environments, teams, or workspaces, this check is especially important.
## Step 5: Use the connection in a workflow
Open a workflow step that uses the connected app and select the connection from the available options.
At this stage, you do not need to build a full production workflow. A simple test step is enough to verify that the connection works correctly.
## Should you make it the default?
If you expect to use the same account often for that app, setting it up as the default connection can make future workflow setup easier.
Be more careful if:
* several people use different accounts for the same app
* you have both test and production accounts
* some workflows must stay isolated from others
In those cases, explicit connection selection is usually safer than relying on defaults.
## Common mistakes when creating a connection
The most common early issues are:
* authenticating with the wrong account
* missing a required permission during sign-in
* assuming the connection is active without testing it in a real step
* creating duplicate connections when an existing one would have worked
A quick test run after connection setup is the best way to catch these problems early.
## Recommended next step
After you create a connection, use it in one simple workflow and run a test. That confirms not just that the connection exists, but that it works for the action you actually care about.
# Manage and rotate connections
Source: https://workflowmachine.mintlify.app/connections/manage-and-rotate-connections
Keep your connections healthy over time by reusing them well, updating them when needed, and rotating access safely.
## Why connection management matters
Connections are not a one-time setup task.
Over time, accounts change, permissions get updated, tokens expire, and workflows start depending on the same app access in multiple places. Good connection management helps you avoid unexpected workflow failures later.
## Reuse before you duplicate
In most cases, you should reuse an existing connection instead of creating a new one.
That makes it easier to:
* keep app access consistent
* reduce clutter in the Connections list
* update fewer records when credentials change
Create a separate connection only when there is a clear reason, such as using a different account, a different environment, or a different ownership boundary.
## Keep names clear
As your workspace grows, names matter more.
Use connection names that make it obvious:
* which app the connection belongs to
* which account it uses
* whether it is intended for production, testing, or a specific workflow group
Clear naming reduces mistakes when selecting connections inside workflow steps.
## Understand default connections
Default connections can speed up setup, but they also affect how quickly someone can attach the wrong account to a workflow.
Review default connections carefully when:
* the same app is used by multiple teams
* you have both personal and shared accounts
* you maintain separate test and live environments
Defaults are convenient, but they work best when the ownership model is already clear.
## When to update a connection
You may need to update or replace a connection when:
* the connected account changes
* permissions need to be expanded
* access tokens become invalid
* the workflow should now use a different app account
When this happens, avoid changing several workflows first. Update the connection situation first, then retest the affected workflows.
## Rotation and replacement
Sometimes app credentials or tokens need to be refreshed or replaced.
A safe pattern is:
1. identify which workflows use the connection
2. update or recreate the connection as needed
3. run targeted tests on the affected workflows
4. verify a real run after the change
This reduces the risk of silently breaking workflows that were previously stable.
## Periodic cleanup
It helps to review connections from time to time and ask:
* is this still in use
* is this the right default
* is this clearly named
* is this account still the one we want workflows to use
Small cleanup habits keep the workspace manageable as automation usage grows.
## What good connection management looks like
A healthy setup usually has:
* a small number of well-named reusable connections
* clear separation between test and production accounts when needed
* deliberate use of defaults
* regular retesting after credential changes
That kind of setup makes workflows easier to trust because the integration layer underneath them is more stable.
# Connections overview
Source: https://workflowmachine.mintlify.app/connections/overview
Understand what connections are, why they matter, and how they fit into workflows across Workflow Machine.
## What connections do
Connections let Workflow Machine access the external apps your workflows use.
Instead of authenticating separately inside every step, you create a connection once in the [Connections](https://app.workflowmachine.com/connections) page and then select it wherever a workflow needs that app. This keeps workflow setup cleaner and makes integrations easier to reuse.
## Why connections matter
Most useful workflows depend on other systems.
For example, a workflow might need to:
* send a Slack message
* read from Gmail
* create a Notion page
* write to Google Sheets
* update a Stripe customer
Connections are what make those app actions possible.
## How connections fit into the product
A simple mental model:
* **Workflows** define the process
* **Triggers** decide when the process starts
* **Steps** do the work
* **Connections** let those steps access external apps
That separation is important because it means one connection can be reused across several workflows instead of being recreated every time.
## Reusable across workflows
One of the biggest benefits of connections is reuse.
You can often use the same connected account in multiple workflows, which helps you:
* avoid repeated auth setup
* keep account access consistent
* update one connection instead of several copies
This is especially helpful once your workspace contains more than a handful of workflows.
## Default connections
Workflow Machine can also treat a connection as the default for its app type.
That makes setup faster because workflows can often pick the expected connection more easily, especially when you use the same app account repeatedly.
If you work with more than one account for the same app, it is worth being deliberate about which connection should be the default and which workflows should use a different one.
## Common connection types
Depending on the integration, a connection may use:
* OAuth sign-in
* API keys or tokens
* another app-specific authentication flow
From a user perspective, the important thing is not the auth mechanism itself. It is whether the connection gives the workflow the right access to do its job.
## What can go wrong
Even a well-designed workflow can fail if the connection behind a step is not usable.
Common issues include:
* the wrong account was connected
* the connection is missing required permissions
* the token expired or became invalid
* the workflow step is pointing to the wrong saved connection
That is why connections deserve their own section in the docs instead of being treated as a minor setup detail.
## Best way to use this section
If you are new to Workflow Machine, read these pages in order:
1. Create a connection from the [Connections](https://app.workflowmachine.com/connections) page
2. Learn how to maintain and rotate connections
3. Use the troubleshooting guide when a step fails unexpectedly
Once you understand connections well, building app-based workflows becomes much smoother.
# Connect your first app
Source: https://workflowmachine.mintlify.app/getting-started/first-integration
Create your first connection in Workflow Machine and learn how connections are reused across workflows.
## Why connections matter
Connections let Workflow Machine access the external apps your workflows depend on.
Instead of authenticating inside every workflow step, you create a connection once and reuse it wherever needed. This keeps workflow setup cleaner and makes it easier to update app access later.
## Step 1: Choose a simple first integration
Pick an app that is easy to verify in a real workflow.
Good first choices:
* **Slack** for sending visible notifications
* **Google Sheets** for logging workflow data
* **Notion** for creating pages or records
* **Gmail** for inbox-based workflows
These are good starting points because the result is usually easy to confirm after a run.
## Step 2: Open Connections
Go to [**Connections**](https://app.workflowmachine.com/connections) and create a new connection for the app you want to use.
Depending on the integration, you may see:
* an OAuth flow in your browser
* fields for API keys or tokens
* required scopes or permissions
Use an account that is appropriate for the workflow you are building. In practice, the wrong account causes almost as many problems as missing auth.
## Step 3: Complete authentication
After signing in or entering credentials, save the connection and confirm that it appears in your Connections list.
At this point, the connection should be available to relevant workflow steps that use that app.
If the app account requires specific permissions, make sure they were granted during setup. A connection that exists but lacks permission can still cause step failures later.
## Step 4: Use the connection in a workflow
Open your workflow from [Workflows](https://app.workflowmachine.com/workflows) and select the step that should use the connected app.
Choose the connection you just created. Then configure the rest of the step fields as usual.
One important benefit of Workflow Machine is that the same connection can be reused across multiple workflows, so you do not have to repeat the auth setup every time.
## Common connection issues
If a step fails and you suspect the connection, check these first:
* the correct app account was connected
* the connection is selected in the step
* the connected account has the permissions the action needs
* the credentials or token have not expired
* you have changed your password recently, which can revoke access for some integrations
If a workflow worked before and suddenly stopped, connection validity is one of the first things to review.
## Best practices
Use these habits early:
* name connections clearly so they are easy to identify later
* reuse existing connections when possible
* avoid creating duplicate connections unless you really need separate accounts
* test with a simple workflow before relying on the integration in a critical process
Good connection hygiene makes larger automation setups much easier to maintain.
## Next steps
Once your first connection is ready, the next step is to use it in a workflow with a real trigger and a test run. If you want a fast win, pair the connection with a simple output step such as sending a message, writing a row, or creating a page.
# Start from a template
Source: https://workflowmachine.mintlify.app/getting-started/first-template
Use templates to launch a workflow faster and learn the product from working examples.
## Why start from a template
Templates are one of the fastest ways to get value from Workflow Machine. Browse [Templates](https://app.workflowmachine.com/templates) to explore available starting points.
Instead of building every workflow from scratch, you can start from a working pattern and adapt it to your own tools, data, and goals.
Templates are especially useful when:
* you already know the business outcome you want
* you want to learn by inspecting a real workflow
* you need a faster path to a first published workflow
## What a template gives you
A template usually provides a starting structure such as:
* one or more triggers
* a sequence of steps
* a suggested workflow use case
You still need to review and customize the details, especially connections, field mappings, and any app-specific configuration.
## How to choose a good template
Pick a template based on the outcome you want, not just the apps it mentions.
Good examples:
* lead capture and routing
* inbox triage
* scheduled digests
* content summarization
* spreadsheet or database logging
If multiple templates look similar, choose the one with the simplest shape first. It is easier to extend a simple workflow than to debug a complex one you do not fully understand yet.
## Before you publish a template
Treat every template like a draft.
Before going live:
* check the trigger configuration
* connect the right app accounts
* verify all required fields
* review the data flow between steps
* run a test
Templates can save time, but they still need your context.
## What to customize first
The most important template edits are usually:
* the workflow name
* the selected connections
* destination channels, documents, or databases
* AI prompt wording
* conditions and output formatting
You do not need to change everything at once. Make the minimum edits needed to fit your process, then test.
## A good way to learn the product
Templates are also a teaching tool.
If you are still getting familiar with triggers, steps, and field mappings, open a template and inspect:
* how the workflow was created in chat, so you can learn how to prompt more effectively
* what starts the workflow
* how the steps are sequenced
* which parts use connections
* how the final result is produced
That makes it easier to understand how to build your own workflows from scratch later.
## When to choose a blank workflow instead
Start from scratch instead of using a template when:
* your process is very specific
* you want to learn the editor directly
* the available templates are more complex than your use case
Both approaches are valid. Templates are about speed, not obligation.
# Build your first workflow
Source: https://workflowmachine.mintlify.app/getting-started/first-workflow
Create a simple workflow with a trigger, a few steps, and a successful published run.
## Goal
Your first workflow should teach you the product, not test your patience.
Aim for a workflow that:
* has one clear trigger
* has one clear outcome
* uses only a few steps
* is easy to test
Examples:
* receive a webhook and send a Slack message
* run on a schedule and generate an AI summary
* capture a form or email event and write a record into Google Sheets
## Step 1: Start with the outcome
Before opening the editor, decide what success looks like.
Good examples of clear outcomes:
* a message appears in Slack
* a row appears in a spreadsheet
* a page is created in Notion
* an email summary is generated
If the outcome is easy to verify, debugging is easier too.
## Step 2: Create the workflow
Open [Home](https://app.workflowmachine.com/) and describe your use case in a prompt.
Then send the prompt to create the workflow.
Workflow Machine will use AI to turn that prompt into a starting workflow draft with the trigger and steps it believes fit your use case.
## Step 3: Review and refine
After the workflow is created, review the draft in the editor and make any changes you want.
You can adjust the trigger, reorder steps, update mappings, remove anything unnecessary, or add extra steps yourself. The AI-generated version is only a starting point.
Keep the first workflow simple. Focus on making one path work clearly from trigger to outcome before adding extra branches or logic.
## Step 4: Run a test
Testing is where the workflow stops being theoretical.
Run a test to:
* confirm that the trigger is valid
* see whether each step executes in sequence
* inspect outputs at each stage
* catch field or auth issues before publishing
If the test fails, isolate the earliest failing step and fix that before changing anything downstream.
## Step 5: Publish the workflow
When the test run looks correct, publish the workflow.
Publishing makes the current version live. After that, real trigger events can create runs.
A good habit is to publish only after:
* the trigger is confirmed
* the critical fields are mapped
* the connection is known to work
* the outcome is easy to verify
## Step 6: Verify a real run
After publishing, trigger the workflow with a real input and review the run history.
Look for:
* whether the workflow started as expected
* whether each step completed
* whether the final output matches the intended result
This final check is important because real inputs often surface issues that test inputs do not.
## Keep improving from there
Once the first version works, you can add:
* better branching
* more robust data handling
* additional integrations
* AI steps for summarization or extraction
* template reuse for similar workflows
Start simple, get one successful run, then iterate.
# Product tour
Source: https://workflowmachine.mintlify.app/getting-started/product-tour
Learn the main areas of Workflow Machine and what you can do in each one.
## How the product is organized
Workflow Machine is centered around a small set of areas that work together:
* [**Home**](https://app.workflowmachine.com/)
* [**Templates**](https://app.workflowmachine.com/templates)
* [**Connections**](https://app.workflowmachine.com/connections)
* [**Workflows**](https://app.workflowmachine.com/workflows)
* [**Settings**](https://app.workflowmachine.com/settings)
Understanding what belongs in each area makes it easier to find what you need and build workflows without guesswork.
## Home
[Home](https://app.workflowmachine.com/) is the starting point for new and returning users.
Use it to:
* understand what Workflow Machine can do
* jump into common setup tasks
* discover templates and workflow ideas
If you are not sure what to automate first, start here before opening the workflow editor.
## Templates
[Templates](https://app.workflowmachine.com/templates) help you start from a proven pattern instead of a blank page.
Use templates when you want to:
* learn by example
* launch a common workflow faster
* adapt an existing structure to your own process
Templates are especially helpful when you already know the business outcome you want, but do not want to design every step from scratch.
## Connections
[Connections](https://app.workflowmachine.com/connections) store the authenticated app accounts your workflows use.
This is where you:
* connect services like Slack, Gmail, Notion, or Google Sheets
* troubleshoot auth problems
* maintain reusable app access across multiple workflows
Many workflow issues can be traced back to connection setup, so this section is an important part of day-to-day use.
## Workflows
[Workflows](https://app.workflowmachine.com/workflows) are where you create, edit, test, publish, and monitor automations.
This is the core working area of the product. Inside a workflow, you will typically:
* add a trigger
* add and reorder steps
* configure connections and fields
* test the workflow
* review runs and versions
If Home is the starting point, Workflows is where the actual automation work happens.
## Settings
Settings covers account and subscription-related information such as your [profile](https://app.workflowmachine.com/settings/profile) and [subscription](https://app.workflowmachine.com/settings/subscription).
Depending on what is available in your workspace, you may use Settings to:
* review your current plan
* check usage
* manage billing-related details
If you are trying to understand limits, run credits, or AI credits, this is the section to check.
## A simple way to think about it
Here is a practical mental model:
* **Home** helps you start
* **Templates** help you accelerate
* **Connections** help you authenticate
* **Workflows** help you build
* **Settings** help you manage usage and plan details
Once this structure feels familiar, the rest of the product becomes much easier to navigate.
## Recommended path for new users
If you are just starting out, this order works well:
1. Read the quickstart.
2. Create one connection.
3. Build one simple workflow.
4. Run a test.
5. Publish it and inspect the first run.
That flow gives you exposure to the most important parts of the product without trying to learn everything at once.
# Quickstart
Source: https://workflowmachine.mintlify.app/getting-started/quickstart
Set up Workflow Machine, connect your first app, and publish a simple workflow.
## What you will do
This quickstart walks you through the shortest path to a working workflow:
1. Sign up and onboard.
2. Connect apps.
3. Create a workflow via prompting.
4. Test the workflow.
5. Publish it and verify the first run.
If this is your first time using Workflow Machine, keep the first workflow small. A simple trigger and two or three steps is enough to learn the product.
## Before you start
Choose one outcome you want to automate. Good first examples include:
* Send a Slack message when a webhook is received
* Run a scheduled workflow that summarizes updates
* Collect data from one app and write it into another
You will also want access to at least one app account you can connect, such as Slack, Gmail, Notion, Google Sheets, or Stripe.
## Step 1: Open Workflow Machine
After signing in, you will land in the main product area. The most important sections for a new user are:
* [**Home**](https://app.workflowmachine.com/) for entry points and templates
* [**Templates**](https://app.workflowmachine.com/templates) for prebuilt workflow ideas
* [**Connections**](https://app.workflowmachine.com/connections) for app authentication
* [**Workflows**](https://app.workflowmachine.com/workflows) for creating and editing automations
* [**Settings**](https://app.workflowmachine.com/settings) for profile, subscription and usage information
If you are not sure where to begin, use a template. If you want to understand the product from first principles, start from a blank workflow.
## Step 2: Connect your first app
Before many steps can work, you need a connection.
Open [**Connections**](https://app.workflowmachine.com/connections) and create a connection for the app you plan to use. Depending on the integration, this may use OAuth or API keys.
Good first connection choices:
* Slack for notifications
* Gmail for inbox workflows
* Notion for creating or updating pages
* Google Sheets for logging records
Once a connection is created, you can reuse it across multiple workflows.
## Step 3: Create a workflow
Under [**Home**](https://app.workflowmachine.com/):
* Describe your use case
* Send the prompt
After you send the prompt, Workflow Machine uses AI to work through the workflow setup and assemble the trigger and steps needed for your use case. This gives you a starting workflow structure that you can review, refine, and test before publishing.
## Step 4: Review and refine the workflow
Once the workflow draft is created, review it in the editor and make any changes you want. You can update the trigger, adjust the step order, edit field mappings, remove steps that are not needed, or add new ones yourself.
The workflow does not need to stay exactly as AI generated it. You can manually shape it until it matches the process you actually want to run.
For a first workflow, keep the structure simple and focus on one clear outcome. After the basic flow looks right, move on to testing.
## Step 5: Test before publishing
Before publishing, run a test.
You can test the workflow in different ways depending on what you want to validate:
* Test a single trigger
* Test a single step
* Test a full run using a specific trigger
Testing helps you:
* Check whether the trigger is configured correctly
* Confirm that connected accounts work
* Inspect step outputs
* Catch mapping mistakes before the workflow goes live
If something looks wrong, you can also use AI to help diagnose the issue and suggest what to adjust in the workflow.
If a test fails, inspect the step that failed first. Most early problems come from:
* Missing connection setup
* Required fields not being filled in
* Data shape mismatches between steps
* A trigger that was configured differently than expected
## Step 6: Publish and verify the first run
Once the test passes, publish the workflow.
After publishing:
* Trigger it with a real input
* Open the run history
* Verify that each step completed as expected
This matters because a passing test is helpful, but a real run confirms that your trigger, connection, and downstream actions all behave correctly in normal conditions.
## Recommended first workflow patterns
If you want something easy to prove out quickly, start with one of these:
* Webhook in, Slack message out
* Schedule in, AI summary out
* Form response in, spreadsheet row out
* Email in, AI classification plus notification out
Each pattern teaches one core part of the product without requiring a large setup.
## Next steps
Learn how the main areas of the app fit together.
Follow a more detailed workflow creation guide.
Learn how connections work and how to avoid common auth issues.
Learn the core concepts behind triggers, steps, runs, and versions.
# Workflow Machine
Source: https://workflowmachine.mintlify.app/index
Build AI-powered workflows that connect your apps, automate repetitive work, and help your team move faster.
## Automate work across your apps
Workflow Machine helps you build workflows that connect the tools your team already uses. You can trigger automations from webhooks, schedules, RSS feeds, and connected apps, then use steps to move data, call external services, and generate AI-powered outputs.
Whether you want to route leads, summarize incoming messages, update internal systems, or keep teams in sync, Workflow Machine gives you one place to design, test, and run those workflows.
Add triggers and steps to create automations without stitching together separate tools by hand.
Work with tools like Slack, Gmail, Notion, Google Workspace, Stripe, Outlook, Telegram, and more.
Add AI steps for summarization, extraction, classification, drafting, and other text-heavy tasks.
Test workflows before publishing, inspect run history, and debug step outputs when something fails.
## What you can build
Workflow Machine is flexible enough for lightweight automations and multi-step operational workflows.
Send form responses or inbound emails into Slack, Google Sheets, or your follow-up process.
Classify messages, draft replies, notify the right team, and keep customer conversations moving.
Turn documents, RSS items, comments, or analytics into summaries, drafts, and digest updates.
Sync systems, enrich records, send alerts, and automate repeatable processes across your stack.
## How Workflow Machine works
Every workflow follows the same core pattern:
1. A trigger starts the workflow.
2. Steps process data, call connected apps, or use AI.
3. You test the workflow before publishing it.
4. Published workflows create runs that you can monitor and troubleshoot.
This makes it easier to start simple, then expand a workflow as your process grows more complex.
## Start here
Set up your workspace, connect an app, and publish your first workflow.
Learn the basic flow for adding a trigger, steps, and test runs.
See which apps you can connect and how triggers and actions work.
Start from proven workflow patterns instead of building everything from scratch.
## Built for real operational work
Workflow Machine is designed for teams that need more than isolated automations. It brings together connected apps, AI steps, reusable connections, workflow testing, and run visibility so you can build processes that are easier to trust and maintain.
If you are just getting started, begin with the quickstart. If you already know the outcome you want, go straight to the workflow guides and integrations reference.
# Discord
Source: https://workflowmachine.mintlify.app/integrations/discord
Use Discord in Workflow Machine for community notifications, message-based workflows, and operational updates.
## What Discord is good for
Discord is useful when workflows need to send updates into a community or team communication space.
Typical uses include:
* event notifications
* support or community alerts
* content update announcements
* workflow summaries
## Common workflow patterns
Discord is a strong fit for:
* message routing
* broadcast-style alerts
* community moderation or review support
* operational notifications for distributed teams
## Triggers and actions
Discord workflows usually focus on message-driven updates and supported event activity. Check the step picker for the exact Discord triggers and actions available in your workspace.
## Connection requirements
Before using Discord:
* create a Discord connection
* confirm the correct server or environment is connected
* verify the workflow can access the intended channels or destinations
## Troubleshooting tips
If a Discord step fails, check:
* whether the selected connection is correct
* whether the destination channel is accessible
* whether the workflow expects message behavior the connected environment does not allow
# Dropbox
Source: https://workflowmachine.mintlify.app/integrations/dropbox
Use Dropbox in Workflow Machine for file-based workflows, uploads, moves, copies, and shared file handling.
## What Dropbox is good for
Dropbox is useful when workflows need to work with files and folders.
Typical examples include:
* uploading files
* moving or renaming files
* creating folders
* generating shareable file links
## Common workflow patterns
Dropbox is a good fit for:
* document intake workflows
* automated file organization
* file handoff processes
* content distribution workflows
## Triggers and actions
Dropbox workflows usually focus on file events and file operations. Check the step picker for the currently available Dropbox triggers and actions in your workspace.
## Connection requirements
Before using Dropbox:
* create a Dropbox connection
* confirm the correct account is connected
* verify the workflow has access to the target folders and files
## Troubleshooting tips
If a Dropbox step fails, check:
* whether the file path or folder target is correct
* whether the selected account has access
* whether the workflow is trying to operate on a file that no longer exists
# Gmail
Source: https://workflowmachine.mintlify.app/integrations/gmail
Use Gmail in Workflow Machine for inbox workflows, triage, and email-driven automation.
## What Gmail is good for
Gmail is useful when workflows begin from inbox activity or need to take action on email.
Typical use cases include:
* inbound message triage
* lead qualification
* support intake
* email summaries
* follow-up or routing workflows
## Common workflow patterns
Gmail is a strong fit for workflows that:
* watch for new email activity
* classify messages with AI
* draft or trigger downstream responses
* pass key details into Slack, Notion, or Google Sheets
## Triggers and actions
Gmail-related workflows are usually centered on incoming message activity and follow-up handling. Available trigger and action support can vary by current product configuration, so use the workflow step picker to confirm what is available in your workspace.
## Connection requirements
Before using Gmail:
* create a Gmail connection
* confirm you are using the right inbox account
* verify the connected account has the permissions needed for the workflow
## Troubleshooting tips
If Gmail steps behave unexpectedly, check:
* whether the right inbox was connected
* whether the workflow is using the expected connection
* whether the incoming message pattern matches your assumptions
* whether downstream steps can handle the email data shape
# Google Analytics
Source: https://workflowmachine.mintlify.app/integrations/google-analytics
Use Google Analytics in Workflow Machine for reporting workflows, summaries, and recurring performance updates.
## What Google Analytics is good for
Google Analytics is useful when workflows need reporting data for downstream summaries, alerts, or recurring updates.
Typical use cases include:
* scheduled performance digests
* AI-generated analytics summaries
* internal reporting workflows
* combining metrics with notifications
## Common workflow patterns
Google Analytics is a strong fit for:
* recurring report workflows
* marketing digest automation
* campaign or traffic summaries
* operational visibility for teams that need regular metrics
## Triggers and actions
Analytics workflows are commonly centered on fetching report data and sending it elsewhere. Check the step picker for the exact Google Analytics steps supported in your workspace.
## Connection requirements
Before using Google Analytics:
* create a Google Analytics connection
* confirm the correct Google account is connected
* verify it can access the properties or reports the workflow needs
## Troubleshooting tips
If an Analytics step fails, check:
* whether the right property or account is being used
* whether the workflow expects data that the selected report does not return
* whether the connection still has access to the analytics source
# Google Calendar
Source: https://workflowmachine.mintlify.app/integrations/google-calendar
Use Google Calendar in Workflow Machine for event-based workflows, scheduling automation, and follow-up tasks.
## What Google Calendar is good for
Google Calendar is useful when workflows revolve around meetings, availability, or event scheduling.
Typical uses include:
* creating or updating calendar events
* checking schedules
* building meeting prep workflows
* generating summaries or reminders tied to events
## Common workflow patterns
Google Calendar is a good fit for:
* meeting agenda workflows
* event follow-up automations
* availability-aware scheduling support
* recurring reporting tied to calendar activity
## Triggers and actions
Calendar workflows are usually most valuable when they help a workflow react to or manage event information. Check the step picker for the exact Google Calendar triggers and actions available in your workspace.
## Connection requirements
Before using Google Calendar:
* create a Google Calendar connection
* confirm the correct Google account is connected
* make sure the account can access the calendars the workflow needs
## Troubleshooting tips
If a calendar step fails, check:
* whether the selected calendar is accessible
* whether the correct connection was chosen
* whether the event data includes the fields the step expects
* whether permissions allow create, update, or lookup behavior
# Google Docs
Source: https://workflowmachine.mintlify.app/integrations/google-docs
Use Google Docs in Workflow Machine for document creation, content appending, and AI-assisted writing workflows.
## What Google Docs is good for
Google Docs works well when a workflow needs to create or add written content to a document.
Use it for:
* meeting notes
* generated drafts
* internal summaries
* workflow-produced reports
## Common workflow patterns
Google Docs is a strong fit for workflows that:
* turn structured data into readable content
* append updates over time
* create documents from incoming events
* combine AI-generated text with team workflows
## Triggers and actions
Document workflows are typically centered on creating, retrieving, or appending content. Check the step picker for the specific Google Docs steps supported in your workspace.
## Connection requirements
Before using Google Docs:
* create a Google Docs connection
* confirm the correct Google account is connected
* verify it can access or create documents in the expected environment
## Troubleshooting tips
If a Docs step fails, check:
* whether the selected document exists and is accessible
* whether the connection has permission to modify it
* whether the workflow is sending content in the expected format
# Google Forms
Source: https://workflowmachine.mintlify.app/integrations/google-forms
Use Google Forms in Workflow Machine for response-driven workflows and intake automation.
## What Google Forms is good for
Google Forms is useful when a workflow should start from submitted responses.
Typical use cases include:
* lead intake
* event signup workflows
* internal request handling
* form-driven routing or logging
## Common workflow patterns
Google Forms works well for workflows that:
* capture new responses
* notify a team
* store responses elsewhere
* classify or summarize responses with AI
## Triggers and actions
Form-based workflows usually begin from response events and then pass data into other systems. Check the step picker for the exact Google Forms trigger and action support in your workspace.
## Connection requirements
Before using Google Forms:
* create a Google Forms connection
* confirm the correct Google account is connected
* make sure the account can access the form you want to use
## Troubleshooting tips
If a Forms workflow does not behave as expected, check:
* whether the trigger is tied to the right form
* whether the response data includes the fields you expect
* whether downstream steps are mapped to the right response values
# Google Sheets
Source: https://workflowmachine.mintlify.app/integrations/google-sheets
Use Google Sheets in Workflow Machine for logging, tracking, and lightweight operational data workflows.
## What Google Sheets is good for
Google Sheets is one of the most practical integrations for straightforward workflow outputs.
It is a strong fit for:
* logging workflow results
* tracking leads or requests
* building lightweight reports
* keeping a simple shared record of activity
## Common workflow patterns
Google Sheets is often used for:
* new lead logging
* workflow audit rows
* form-response tracking
* scheduled report output
## Triggers and actions
Sheets workflows usually focus on writing records and, in some cases, responding to row-based changes. Check the step picker for the specific Google Sheets triggers and actions available in your workspace.
## Connection requirements
Before using Google Sheets:
* create a Google Sheets connection
* confirm the correct Google account is connected
* verify the account can access the target spreadsheet
## Troubleshooting tips
If a Sheets step fails, check:
* whether the spreadsheet is accessible
* whether the connection is the right account
* whether the workflow is mapping fields in the right order and shape
# Google Tasks
Source: https://workflowmachine.mintlify.app/integrations/google-tasks
Use Google Tasks in Workflow Machine for task creation, task updates, and lightweight follow-up automation.
## What Google Tasks is good for
Google Tasks is useful when the workflow outcome is a lightweight personal or team follow-up item.
Use it for:
* creating reminders
* generating follow-up tasks
* updating or completing tasks as workflows progress
## Common workflow patterns
Google Tasks is a strong fit for:
* lead follow-up reminders
* support follow-up tasks
* recurring personal operations
* event-driven task creation
## Triggers and actions
Task workflows usually focus on creating, updating, completing, or monitoring tasks and task lists. Check the step picker for the exact Google Tasks triggers and actions available in your workspace.
## Connection requirements
Before using Google Tasks:
* create a Google Tasks connection
* confirm the correct Google account is connected
* verify it has access to the lists you want to use
## Troubleshooting tips
If a Tasks step fails, check:
* whether the right task list is selected
* whether the connection points to the intended account
* whether the workflow is expecting fields the task source does not provide
# Microsoft OneDrive
Source: https://workflowmachine.mintlify.app/integrations/microsoft-onedrive
Use OneDrive in Workflow Machine for file management, uploads, searches, and file-driven automations.
## What OneDrive is good for
OneDrive is useful when workflows need to create, find, move, rename, or upload files inside Microsoft environments.
Typical use cases include:
* document intake
* automated file organization
* shared asset workflows
* file event monitoring where supported
## Common workflow patterns
OneDrive works well for:
* moving files between folders
* creating new workflow-generated files
* finding files before taking downstream action
* kicking off internal file-based processes
## Triggers and actions
OneDrive workflows are usually centered on file events and file operations. Check the step picker for the exact OneDrive triggers and actions available in your workspace.
## Connection requirements
Before using OneDrive:
* create a OneDrive connection
* confirm the correct Microsoft account is connected
* verify it has access to the target files and folders
## Troubleshooting tips
If a OneDrive step fails, check:
* whether the workflow is using the correct account
* whether the target path is valid
* whether the file or folder permissions allow the requested action
# Microsoft Outlook
Source: https://workflowmachine.mintlify.app/integrations/microsoft-outlook
Use Outlook in Workflow Machine for email workflows, calendar actions, and Microsoft-based operational automation.
## What Outlook is good for
Outlook is useful when workflows need to interact with Microsoft email and calendar activity.
Typical uses include:
* email triage
* draft creation
* event creation and updates
* contact and follow-up workflows
## Common workflow patterns
Outlook is a strong fit for:
* support or sales inbox automation
* calendar-driven follow-up workflows
* outbound update workflows
* message handling and routing
## Triggers and actions
Outlook workflows often combine email and calendar operations in the same process. Check the step picker for the specific Outlook triggers and actions available in your workspace.
## Connection requirements
Before using Outlook:
* create an Outlook connection
* confirm the correct Microsoft account is connected
* verify the account has access to the inboxes, calendars, or contacts involved
## Troubleshooting tips
If an Outlook step fails, check:
* whether the account is the intended one
* whether the mailbox or calendar permissions are sufficient
* whether the target resource still exists and is accessible
# Notion
Source: https://workflowmachine.mintlify.app/integrations/notion
Use Notion in Workflow Machine for page creation, structured tracking, internal knowledge workflows, and comments-driven automation.
## What Notion is good for
Notion is useful when a workflow should create, update, or organize internal knowledge and operational records.
Typical use cases include:
* creating pages from incoming requests
* updating internal tracking databases
* storing workflow outputs
* watching for changes or comments where supported
## Common workflow patterns
Notion is a strong fit for:
* bug report capture
* documentation workflows
* internal request logs
* content planning and review support
## Triggers and actions
Notion workflows are often centered on creating pages, updating content, working with data sources, and reacting to supported page activity. Check the step picker for the exact Notion triggers and actions available in your workspace.
## Connection requirements
Before using Notion:
* create a Notion connection
* connect the correct workspace
* verify the connected account has access to the pages or databases involved
## Troubleshooting tips
If a Notion step fails, check:
* whether the correct workspace is connected
* whether the target page or database is accessible
* whether the workflow is sending the expected fields and content
# Integrations overview
Source: https://workflowmachine.mintlify.app/integrations/overview
Understand how integrations work in Workflow Machine and how to choose the right app for your workflow.
## Why integrations matter
Integrations are what let workflows interact with the rest of your tool stack.
They are how Workflow Machine moves beyond internal logic and becomes useful in day-to-day operations. Integrations make it possible to receive input from apps, send actions into apps, and coordinate work across several systems.
## Two main roles: triggers and actions
Integrations usually participate in workflows in one or both of these ways:
* **Triggers** start a workflow when an app event happens
* **Actions** let a workflow do something inside an app
Some integrations are mostly action-oriented. Others are strongest as event sources. Many support both.
## How to choose the right integration
Start from the workflow outcome, then choose the app that best matches that job.
Ask:
* where does the event begin
* where should the result go
* which app owns the source of truth
That usually leads to better workflow design than choosing tools first and outcome second.
## Connections come first
Before an integration can be used in a workflow, you usually need a connection for that app.
That means:
* authenticating the account
* choosing the correct workspace or environment
* making sure the account has the permissions the workflow needs
If an integration step fails, connection setup is one of the first things worth checking.
## Use integrations intentionally
The best workflows do not use many apps just because they can. They use the fewest apps needed to get the right result.
That keeps workflows:
* easier to test
* easier to maintain
* easier to troubleshoot
## How to use the integration pages
Each integration page in this section helps you answer:
* what the integration is good for
* what kinds of workflows it supports well
* what connection setup is required
* what common problems to watch for
If you are building a new workflow, start with the app closest to the business outcome you want.
# Postmark
Source: https://workflowmachine.mintlify.app/integrations/postmark
Use Postmark in Workflow Machine for transactional email workflows and reliable outbound message delivery.
## What Postmark is good for
Postmark is useful when a workflow needs to send transactional email as part of a larger process.
Typical use cases include:
* acknowledgment emails
* follow-up notifications
* templated operational messages
* system-generated outbound updates
## Common workflow patterns
Postmark is a strong fit for:
* support confirmation workflows
* transactional status updates
* templated email delivery
* workflow-generated customer communications
## Triggers and actions
Postmark workflows usually focus on sending email or sending email from templates. Check the step picker for the exact Postmark steps available in your workspace.
## Connection requirements
Before using Postmark:
* create a Postmark connection
* confirm the correct sending account or server context is connected
* verify the workflow should use that outbound email setup
## Troubleshooting tips
If a Postmark step fails, check:
* whether the connection is valid
* whether the template or recipient data is correctly mapped
* whether the workflow is sending the expected fields and content
# Slack
Source: https://workflowmachine.mintlify.app/integrations/slack
Use Slack in Workflow Machine for notifications, routing, and team-facing workflow outputs.
## What Slack is good for
Slack is one of the strongest integrations for visible workflow outcomes.
Use it when a workflow should:
* notify a team
* route updates into a channel
* surface important events quickly
* turn workflow results into something people can act on
## Common workflow patterns
Slack is a strong fit for:
* lead alerts
* support escalation messages
* AI-generated summaries
* digest notifications
* internal operational updates
## Triggers and actions
Slack workflows are commonly centered on sending information to people at the right time. Depending on your workspace setup and product support, Slack may be used as an action destination and, in some cases, an event source.
Check the workflow step picker for the currently available Slack triggers and actions in your workspace.
## Connection requirements
Before using Slack in a workflow:
* create a Slack connection
* confirm you are using the correct workspace
* confirm the account has access to the channels or destinations you want
## Troubleshooting tips
If a Slack step fails, check:
* the selected connection
* the target channel or destination
* whether the connected account can post there
* whether the workflow is using the intended workspace
# Stripe
Source: https://workflowmachine.mintlify.app/integrations/stripe
Use Stripe in Workflow Machine for customer-related automations and billing-adjacent workflow triggers.
## What Stripe is good for
Stripe is useful when a workflow needs to react to or update customer and billing-related information.
Typical use cases include:
* customer handoff workflows
* billing-related notifications
* account enrichment based on payment activity
* syncing customer records into other systems
## Common workflow patterns
Stripe is a strong fit for:
* customer creation or update workflows
* financial-event notifications
* support workflows that depend on customer status
* CRM or database syncs
## Triggers and actions
Stripe workflows are commonly centered on customer lookup and update tasks, along with related business events. Check the step picker for the exact Stripe triggers and actions available in your workspace.
## Connection requirements
Before using Stripe:
* create a Stripe connection
* confirm the correct Stripe environment or account is connected
* verify the workflow should use that account rather than a test or alternate one
## Troubleshooting tips
If a Stripe step fails, check:
* whether the correct Stripe account is connected
* whether the workflow is using live or test data intentionally
* whether the customer fields being used actually exist in the incoming or stored data
# Telegram
Source: https://workflowmachine.mintlify.app/integrations/telegram
Use Telegram in Workflow Machine for messaging workflows, notifications, and chat-based automation.
## What Telegram is good for
Telegram is useful when workflows need to send messages or interact with chat-based audiences.
Typical use cases include:
* notifications
* chat-based updates
* bot-style follow-up flows
* lightweight messaging outputs
## Common workflow patterns
Telegram works well for:
* alert workflows
* status updates
* conversational outreach
* location or poll-based messaging where supported
## Triggers and actions
Telegram workflows usually focus on messaging actions and bot-style interactions. Check the step picker for the exact Telegram triggers and actions available in your workspace.
## Connection requirements
Before using Telegram:
* create a Telegram connection
* confirm the correct bot or account is connected
* verify the workflow can reach the intended destination
## Troubleshooting tips
If a Telegram step fails, check:
* whether the workflow is using the intended bot or account
* whether the destination is valid
* whether the selected action matches the kind of message or interaction you want
# Expression syntax
Source: https://workflowmachine.mintlify.app/reference/expression-syntax
Learn the basics of using expressions and templated values inside workflow fields.
## Why expressions matter
Expressions help you build dynamic workflows.
They let steps use values from earlier parts of the workflow instead of relying only on static text or fixed configuration.
## Template style
Workflow Machine uses `{{ ... }}` style expressions.
This is useful when:
* a later step needs data from the trigger
* one step depends on the output of another
* field values should be built dynamically
## Common uses
Expressions are especially useful for:
* building message content
* selecting output fields
* combining values into a readable string
* passing workflow data from one step into another
## Keep expressions simple first
When you start using expressions, prefer simple references over complicated logic.
That makes workflows:
* easier to read
* easier to test
* easier to troubleshoot
If an expression becomes difficult to understand, it may be a sign that some of the logic belongs in a separate step instead.
## A few important rules
The expression system in Workflow Machine includes a few important behaviors:
* expressions use `{{ ... }}` syntax
* arrays use 1-based indexing
* negative indices count from the end
These details matter when you start working with lists and step outputs.
## Best practice
Whenever an expression is important to the workflow result, test the step output that depends on it before publishing. Dynamic values are powerful, but they are easiest to trust when you have seen them work with real data.
# Glossary
Source: https://workflowmachine.mintlify.app/reference/glossary
Review the core terms used throughout Workflow Machine documentation.
## Workflow
An automation made up of a trigger and one or more steps.
## Trigger
The event or schedule that starts a workflow.
## Step
A unit of work inside a workflow, such as an app action, AI task, or control-flow action.
## Run
One execution of a workflow after it starts.
## Connection
The saved authentication that lets Workflow Machine access an external app.
## Template
A reusable starting point for a workflow.
## Publish
The action that makes a workflow live so it can begin creating real runs.
## Run credit
A unit used to measure workflow execution usage.
## AI credit
A unit used to measure AI-related usage inside workflows.
# Run states
Source: https://workflowmachine.mintlify.app/reference/run-states
Understand what common workflow run states mean and how to react to them.
## Why run states matter
Run states tell you what happened after a workflow started.
They are useful because they quickly answer the first debugging question:
“Did the workflow succeed, fail, or stop somewhere in between?”
## Started
**Started** means the workflow began executing.
This confirms the trigger fired and the run was created.
## Completed
**Completed** means the workflow reached the end successfully.
This is the outcome you want for normal healthy runs.
## Failed
**Failed** means the workflow encountered an error it could not recover from.
When a run fails, inspect the first failing step and its input/output data before changing the workflow.
## Stopped
**Stopped** means execution ended intentionally before the workflow completed normally.
This can happen during test or control scenarios where the run should not continue.
## Timeout
**Timeout** means the workflow took too long to finish.
If this happens repeatedly, review:
* the number of steps
* any waiting behavior
* external systems that may be delaying the workflow
## How to use run states well
Run states are most useful when combined with run details.
The state tells you the category of outcome. The run data tells you why it happened.
# Step catalog
Source: https://workflowmachine.mintlify.app/reference/step-catalog
Get a practical overview of the most important step types available when building workflows.
## How to use this catalog
This page is a practical reference, not an exhaustive schema dump.
Use it to understand the major step categories you will encounter when building workflows, then use the workflow editor for the latest exact step list in your workspace.
## Common built-in workflow steps
Some of the most important built-in steps and categories include:
* **AI prompt** for summarization, classification, drafting, and extraction
* **HTTP request** for calling external services
* **Fetch** for retrieving content from URLs
* **Fetch RSS** for working with feed-based sources
* **Send email** for outbound communication
* **Set state** and **Get state** for workflow memory-like state handling
* **If** for branching decisions
* **Wait** for delayed execution
* **End** for early workflow exit
These steps form the backbone of many useful workflows, even before app integrations are added.
## Integration steps
In addition to built-in steps, Workflow Machine also provides app-specific steps through integrations.
Examples include actions for:
* Slack
* Gmail
* Notion
* Google Workspace apps
* Microsoft apps
* Stripe
* Telegram
* Dropbox
The available app steps depend on which integrations the product currently supports in your workspace.
## A practical way to choose steps
When choosing a step, ask:
* is this step for logic, AI, or an app action
* what input does it need
* what output should it produce
* what step will use that output next
If those answers are clear, the step is usually a good fit.
# Trigger catalog
Source: https://workflowmachine.mintlify.app/reference/trigger-catalog
See the main trigger types used in Workflow Machine and when each one is the right choice.
## Core trigger types
Workflow Machine includes several important trigger patterns that are useful across many workflows.
## Webhook
Use **Webhook** when another system should send data directly into the workflow.
Best for:
* custom integrations
* internal systems
* event-driven external tools
## Schedule
Use **Schedule** when time should start the workflow.
Best for:
* recurring digests
* periodic syncs
* recurring checks
## RSS
Use **RSS** when the workflow should react to feed updates.
Best for:
* research monitoring
* content tracking
* industry update digests
## App event triggers
Many integrations expose app-native trigger patterns.
Best for:
* inbox-driven workflows
* file event workflows
* form-response workflows
* record-change workflows
## How to choose the right trigger
The right trigger is the one that matches the natural beginning of the process.
If the workflow starts because something happened, use an event-style trigger. If it starts because time passed, use a schedule.
# Debug failed runs
Source: https://workflowmachine.mintlify.app/runs/debug-failed-runs
Use workflow run history to isolate failures and fix the real cause instead of guessing.
## Start with the first failure, not the final symptom
When a workflow run fails, the most useful question is:
“Where did the behavior first go wrong?”
That is usually more helpful than focusing on the final broken step, because later failures are often just the result of an earlier bad input or bad decision.
## A practical debugging order
Use this sequence:
1. confirm the trigger input
2. find the first step that did not behave as expected
3. inspect that step’s inputs and outputs
4. check whether the problem is logic, mapping, or connection-related
5. retest after fixing one thing at a time
This keeps debugging focused and avoids unnecessary changes.
## Common causes of failed runs
Most failures come from a short list of patterns:
* wrong or missing connection
* required fields not configured
* data shape mismatch between steps
* branch logic that sent the workflow down the wrong path
* AI output that was not suitable for the next step
If you keep these in mind, troubleshooting becomes much faster.
## Avoid changing too much at once
When a run fails, it is tempting to edit several parts of the workflow immediately.
Try not to.
Fix one likely cause, then retest. If you change several things at once, you lose clarity about what actually solved the problem.
## Use failed runs as design feedback
A failed run does not just tell you something is broken. It often tells you something about the workflow design.
For example:
* the trigger may be too broad
* the workflow may need an earlier condition
* the data handoff between steps may be too fragile
* the AI step may need a clearer task
This is why failed runs are frustrating in the moment but useful over time.
## Retest after every meaningful fix
Once you update the workflow, run another test before publishing or relying on the next live run.
The goal is not only to remove the error. It is to confirm the workflow now behaves the way you intended.
# Runs overview
Source: https://workflowmachine.mintlify.app/runs/overview
Learn how workflow runs work and how to use them to understand live and test execution.
## What a run shows you
A run is one execution of a workflow.
Every time the workflow starts, Workflow Machine records a run so you can inspect what happened. Runs are the main way to see whether the workflow behaved as expected in testing and in real usage.
## Why runs matter
Runs help you answer practical questions:
* did the workflow start
* did it finish successfully
* which step failed
* what output did a step produce
Without runs, automation becomes guesswork. With runs, you can inspect behavior instead of assuming it.
## Where runs fit in the workflow lifecycle
The workflow lifecycle usually looks like this:
1. design the workflow
2. test it
3. publish it
4. monitor the resulting runs
That last step matters just as much as the earlier ones. A workflow is only trustworthy if you can understand how it behaves after launch.
## Runs view and workflow context
Workflow Machine exposes runs as part of the workflow experience, alongside editing and versions.
That makes sense because runs are not separate from workflow building. They are how you validate and improve what you built.
## Live runs and test runs
In practice, both live and test execution matter.
* **Test runs** help you validate setup safely
* **Live runs** show how the workflow behaves with real inputs
You should expect to use both. Test runs build confidence, while live runs reveal how the workflow behaves in the real world.
## A good run review habit
When a workflow is new or recently changed, review the first few runs carefully.
That helps you catch:
* incorrect assumptions about trigger data
* unexpected branches
* connection problems
* outputs that are technically valid but not useful
Run review is one of the fastest ways to improve workflow quality.
# Review step data
Source: https://workflowmachine.mintlify.app/runs/review-step-data
Inspect step inputs and outputs to understand how data moves through a workflow.
## Step data explains workflow behavior
If you want to understand why a workflow produced a particular result, step data is often the fastest path.
By reviewing what each step received and produced, you can see whether the workflow logic is behaving the way you think it is.
## What step data is useful for
Reviewing step data helps when you need to:
* understand what the trigger actually provided
* confirm a step output before the next step uses it
* find where the workflow data shape changed unexpectedly
* debug AI or integration results
This is useful in both test runs and live runs.
## Look at the handoff between steps
The most important moment is often not the step itself, but the handoff from one step to the next.
Ask:
* did this step produce what I expected
* did the next step receive the value I intended
* is the output too large, too small, or in the wrong format
Many workflow issues come from those handoffs rather than from the step definitions in isolation.
## Use step data to improve workflow design
Step review is not just for debugging failures.
It is also useful for improving:
* field mappings
* branching decisions
* AI prompt design
* output formatting
If a workflow works but feels fragile, step data usually shows you why.
## A good review habit
Whenever you add a new important step, inspect its output during testing before you trust downstream behavior. That small habit prevents a lot of confusion later.
# Monitor usage through runs
Source: https://workflowmachine.mintlify.app/runs/usage-monitoring
Use run history and usage information together to understand how often workflows execute and where credits are being consumed.
## Runs are part of usage awareness
Usage numbers are more helpful when you connect them to actual workflow behavior.
Run history helps you understand:
* which workflows are running often
* whether those runs are producing value
* where unexpected execution volume might be coming from
This is why usage monitoring is not only a billing topic. It is also an operations topic.
## What to watch for
When reviewing runs for usage patterns, look for workflows that:
* trigger more often than expected
* execute too many unnecessary steps
* rely heavily on AI where a simpler approach would work
* fail repeatedly and keep consuming resources
These patterns often point to workflows that should be simplified or tightened.
## Connect run history to workflow design
If a workflow is consuming more run credits than expected, ask:
* is the trigger firing too often
* does the workflow contain unnecessary steps
* is the branching logic doing too much extra work
If AI usage is higher than expected, ask:
* is the AI step essential
* is it running more often than intended
* could the task be narrowed to reduce waste
## Review high-traffic workflows first
You do not need to audit every workflow equally.
Start with:
* workflows that run frequently
* workflows that include AI steps
* workflows tied to production operations
These tend to have the biggest impact on both usage and user trust.
## Healthy usage habits
A few habits go a long way:
* review the first runs after publishing
* revisit workflows that fire on schedules
* simplify workflows that do more work than needed
* fix repeated failures quickly
The goal is not to minimize usage at all costs. The goal is to make sure usage reflects useful automation, not accidental complexity.
# Profile and workspace settings
Source: https://workflowmachine.mintlify.app/settings/profile-and-team
Understand the profile and workspace-related settings available in Workflow Machine.
## What this section is for
Settings help you manage the account and workspace context around your workflows, including your [Profile](https://app.workflowmachine.com/settings/profile) and related workspace details.
This part of the product is less about building automation and more about understanding who is using the workspace, what plan it is on, and how usage is tracked.
## Profile basics
Your profile and account context matter because workflows are created and maintained by real people, not just by the system.
Depending on what is exposed in your workspace, profile-related settings may help you confirm:
* the account you are signed in with
* the workspace context you are currently operating in
* which billing and usage information applies to you
## Workspace context
Even when you are focused on workflows, it helps to know the broader workspace context around them.
That includes:
* which account owns the current work
* which subscription and usage settings apply
* which shared connections or workflows may affect other people
## Why settings still matter to workflow builders
You may not spend most of your time in Settings, but it becomes important when you need to answer questions like:
* why can I not do more of this
* where do I check usage
* which subscription plan is active
That is why this section belongs in end-user docs even though it is not part of the workflow editor itself.
# Subscription and billing
Source: https://workflowmachine.mintlify.app/settings/subscription-and-billing
Understand plans, billing cycles, and how subscription limits shape workflow usage.
## Why subscription details matter
Workflow Machine plans affect how much automation your workspace can run and how long key workflow history is retained.
This is useful context when you are deciding:
* how many workflows to run
* how frequently they should execute
* how much AI usage makes sense
## Current plan structure
The product currently defines three main plans:
* **Free**
* **Starter**
* **Pro**
These plans differ in credits, AI credits, publish limits, history retention, and workflow operating limits.
## Billing cycles
Paid plans support monthly and yearly billing.
If your workspace is on a paid plan, the [Subscription](https://app.workflowmachine.com/settings/subscription) page is where you review:
* the active plan
* the billing cycle
* the next billing timing
## What plan limits affect
Subscription features can influence things like:
* run credits
* AI credits
* maximum live publishes
* run history retention
* version history retention
* workflow runtime limits
That means billing is not separate from workflow design. It affects how much automation the workspace can support comfortably.
## When to look at this page
Use the [Subscription](https://app.workflowmachine.com/settings/subscription) page when:
* workflows are hitting usage limits
* you want to understand what your current plan includes
* you are deciding whether the workspace needs a higher plan
## A practical way to think about it
Subscription and billing are not just procurement details. They are part of capacity planning for automation.
If your workflows are important to daily operations, understanding the limits of the current plan is worth doing early.
# Usage and limits
Source: https://workflowmachine.mintlify.app/settings/usage-and-limits
Monitor run credits, AI credits, and workflow limits so your automations stay reliable and predictable.
## Why usage should be reviewed regularly
Usage tells you whether your workflows are operating at the scale you expect.
It helps you spot:
* workflows that fire too often
* AI-heavy workflows that are more expensive than expected
* workspaces that are approaching subscription plan limits
## Two main usage categories
The product tracks:
* **run credits**
* **AI credits**
These represent different kinds of activity and should be monitored together, not separately.
## Limits are part of workflow design
Usage is not only something to check after a workflow is live. It should influence how you design workflows from the beginning.
For example:
* frequent schedules should be intentional
* long step chains should justify their value
* AI should be used where it clearly improves the result
## What to monitor over time
Check usage when:
* a workflow is new
* a schedule changes
* AI usage increases
* a workflow starts running more often than expected
This helps you catch issues before they become expensive or disruptive.
## Where limits show up in practice
Plan limits can affect:
* how much workflow activity the workspace can sustain
* how many live workflows can be published
* how much history is retained
* how long workflows can run
If a workflow becomes operationally important, its usage profile is worth monitoring just as closely as its outputs.
# Browse and use templates
Source: https://workflowmachine.mintlify.app/templates/browse-and-install-templates
Find a template that matches your workflow goal, review it carefully, and adapt it to your own process.
## Start from the outcome
The best way to browse templates is by the result you want, not just the app names you recognize.
Ask:
* what should this workflow accomplish
* what event should start it
* what final output do I want
That will usually lead you to a better template choice than searching only by tool.
## What to review before using a template
When a template looks promising, inspect:
* the trigger type
* the main steps
* which apps it expects
* whether the final output matches your use case
You do not need an exact match. You need a close enough starting point.
## Customize the important parts first
After choosing a template, review these first:
* workflow name
* selected app connections
* channels, documents, sheets, or destinations
* prompt wording for AI steps
* conditions and branches
These are the parts most likely to need your business context.
## Keep the first adaptation small
Do not feel pressure to improve the template everywhere at once.
The best path is usually:
1. make the minimum changes needed
2. confirm the workflow works
3. improve it after you see test and live runs
That is faster and more reliable than redesigning the template before you know whether the core flow already fits.
## Always test before publishing
Even a strong template can fail if:
* a connection is missing
* the wrong account is selected
* required fields are not mapped
* your real input shape differs from the assumed one
Treat every template like a draft until it passes a test in your own workspace.
# Common recipes
Source: https://workflowmachine.mintlify.app/templates/common-recipes
Start from a few practical workflow recipes that are easy to build and easy to verify.
## Slack alerting
A classic first workflow:
1. receive a webhook or app event
2. format the important details
3. send a Slack message
This is a good starter because the output is immediately visible.
## Gmail triage
A strong inbox workflow pattern:
1. watch for new messages
2. use AI to summarize or classify them
3. route the result to the right system or person
This is useful when the team handles repeated inbound requests.
## Notion updates
Use this recipe when the workflow should create or update internal knowledge:
1. collect the source input
2. transform or summarize it
3. create or update the matching Notion content
This is helpful for structured note capture and lightweight operational tracking.
## Google Sheets logging
A very practical automation pattern:
1. trigger on a new event
2. map the important fields
3. insert a row into a spreadsheet
This is a great way to build audit trails, lead logs, or lightweight reporting.
## Calendar-driven workflows
When timing matters, calendar-based workflows can help with:
* agenda generation
* reminders
* post-meeting summaries
* event-driven follow-up
These workflows are especially effective when combined with AI summarization or downstream notifications.
## Why recipes are useful
Recipes give you a mental shortcut.
They help you recognize that many workflows are just variations of a few repeatable structures. Once you understand the structure, adapting it to a new business case becomes much easier.
# Templates overview
Source: https://workflowmachine.mintlify.app/templates/overview
Understand what workflow templates are, when to use them, and how they help you launch automations faster.
## Why templates exist
Templates help you move faster when you already know the outcome you want. Browse [Templates](https://app.workflowmachine.com/templates) to explore available starting points.
Instead of starting with a blank workflow, you can begin from a prepared structure that already includes a trigger pattern, a useful step sequence, or a proven use case.
## What templates are good for
Templates work especially well when:
* you want a faster first win
* you want to learn from real workflow examples
* your use case is common enough to match an existing pattern
Typical examples include notifications, lead routing, AI summaries, spreadsheet logging, and scheduled digests.
## What templates are not
A template is not a finished deployment.
You still need to:
* connect your own apps
* choose the right destinations
* check the fields and mappings
* run tests before publishing
Templates reduce setup time, but they do not remove the need for review.
## When to use a template
Choose a template when speed matters more than designing every part from scratch.
Templates are a strong fit when:
* you already understand the business outcome
* you want a shortcut to a working structure
* you prefer learning by editing something real
## When to start from scratch
Start from scratch when:
* the workflow is highly specific
* the available templates feel too broad or too complex
* you want to learn the editor in a more hands-on way
Both approaches are valid. Templates are a tool, not a requirement.
## A good template habit
The safest way to use a template is:
1. choose the closest match
2. simplify it if needed
3. connect your apps
4. test it
5. publish only after you understand the flow
That helps templates save time without turning them into black boxes.
# Use case library
Source: https://workflowmachine.mintlify.app/templates/use-case-library
Browse common workflow patterns by category and use them as inspiration for your own automations.
## Why use cases are helpful
Many teams know they want automation, but not which workflow to build first.
Use cases help bridge that gap by turning broad ideas into concrete workflow patterns you can test, adapt, and launch.
## AI workflows
Strong AI-focused workflow ideas include:
* summarize long emails into short action briefs
* classify inbound requests by topic or urgency
* draft replies or updates from raw input
* turn RSS items or analytics into readable digests
* extract structured details from unstructured text
These workflows work best when the AI step has one clear job and the downstream output is easy to verify.
## Lead management workflows
Useful lead workflows often include:
* capture new form responses and notify sales
* qualify inbound emails with AI
* log leads into a spreadsheet or database
* create follow-up tasks after a delay
* hand off qualified activity to the next team
These are often good first workflows because the business outcome is clear.
## Customer support workflows
Support-oriented workflows often focus on speed and consistency:
* acknowledge new support requests
* classify or summarize incoming messages
* route high-priority issues to the right channel
* turn bug reports into structured internal records
* generate recurring support summaries
These workflows are especially useful when the team handles large message volume.
## Content and research workflows
Common examples include:
* turn source material into a first draft
* collect feed updates into a daily or weekly digest
* summarize discussions into internal notes
* convert analytics into plain-language updates
* keep an editorial or documentation pipeline moving
These workflows are often a strong match for AI steps.
## Internal operations workflows
Operations workflows usually help move information between systems:
* sync data from one tool into another
* send alerts when important records change
* create recurring reports
* enrich internal records
* reduce manual copy-and-paste work
This category is broad, which makes it a great place to look once you already understand your own process pain points.
## How to use this library
When you find a use case that matches your goal:
1. identify the trigger
2. identify the outcome
3. choose whether to start from a template or a blank workflow
4. keep the first version simple
The goal is not to copy a use case perfectly. The goal is to use it as a launch point.
# Why Workflow Machine
Source: https://workflowmachine.mintlify.app/why-workflow-machine
Understand where Workflow Machine fits, what problems it solves, and why teams use it to automate work across their apps.
## A practical way to automate work
Most teams do not need more software for the sake of software. They need a reliable way to move information between tools, reduce repetitive work, and respond faster when something important happens.
Workflow Machine is built for that job. It helps you create workflows that connect your apps, run on clear triggers, and use AI where it adds value instead of making the whole process harder to trust.
## Where it fits
Workflow Machine sits between the tools your team already uses.
It watches for events, receives incoming data, runs logic, and takes action across connected systems. Instead of asking your team to manually copy updates between apps or maintain brittle one-off automations, you can design a repeatable workflow once and let it run consistently.
Typical examples include:
* capturing leads from forms and routing them to the right follow-up channel
* summarizing emails, documents, or discussions with AI
* syncing data between operational tools
* sending alerts when specific business events happen
* creating internal digests, reports, or drafts automatically
## Designed for people and AI
Workflow Machine is designed from the ground up to make workflows accessible to both users and AI systems. Compared with tools like Zapier, Make, and n8n, we aim to keep the workflow model simpler and easier to understand so humans can build with confidence and AI can reason about the structure more reliably.
That focus on clarity makes it easier to create workflows from prompts, because the platform is designed to be interpretable instead of overly complex.
## Why teams choose it
### It combines apps, logic, and AI in one workflow
Many tools handle only one part of the job. Workflow Machine lets you combine triggers, branching logic, external app actions, and AI-powered steps inside the same workflow.
### It is designed for workflows, not just prompts
AI is useful, but most business work still needs structure. Workflow Machine gives you that structure with triggers, ordered steps, test runs, and predictable execution flow.
### It keeps connected accounts reusable
Connections are managed separately from workflows. That makes it easier to reuse the same app account across multiple workflows instead of setting up auth repeatedly.
### It gives you visibility after launch
Automation is only useful if you can understand what happened. Workflow Machine lets you inspect run history, review step outputs, and troubleshoot failures when a workflow does not behave as expected.
## When it works best
Workflow Machine is a strong fit when you want to:
* automate processes that span several apps
* reduce manual copy-and-paste work
* add AI to a business process without losing structure
* create reusable internal workflows for operations, support, sales, or content work
* standardize how your team handles recurring tasks
## What makes a good first workflow
The best first workflow usually has:
* one clear trigger
* one clear outcome
* a short sequence of steps
* a result that is easy to verify
Good starting examples include:
* when a form response arrives, log it and notify a team channel
* when an email arrives, summarize it and save the result somewhere useful
* on a schedule, collect updates from one source and send a digest to another
These are simple enough to test quickly, but useful enough to prove the value of the platform.
## What to do next
Learn the basic setup flow and publish your first working automation.
Go deeper on how to design a workflow from scratch.
See which connected apps and workflow building blocks are available.
Start from existing workflow ideas and adapt them to your process.
# Add a trigger
Source: https://workflowmachine.mintlify.app/workflows/add-a-trigger
Choose the right trigger for your workflow and configure it so the automation starts in the right way.
## The trigger defines how the workflow starts
The trigger is the event that starts the workflow and provides the first input.
That makes it one of the most important design choices in the whole automation. A workflow with the wrong trigger often becomes harder to understand, harder to test, and harder to trust.
## Start with the real event
Ask:
* what exact event should start this process
* should the workflow begin because something happened or because time passed
* what input data should be available at the start
Those answers usually point you toward the right trigger quickly.
## Common trigger patterns
These are the most common starting points:
* **Webhook** when another system should send data into Workflow Machine
* **Schedule** when the workflow should run at a recurring time
* **RSS** when the workflow should react to feed updates
* **App event trigger** when a connected integration already provides the event you need
Choose the trigger that most naturally matches the process instead of forcing the workflow into an awkward shape.
## A workflow can have more than one trigger
Some workflows use multiple triggers.
These triggers are independent from each other. Each one can start the workflow on its own and send data into the same workflow logic without affecting the others.
This is useful when you want the same sequence of steps to run from multiple sources.
## Configure the trigger with testing in mind
A good trigger is easy to validate before publishing.
That usually means:
* the event is easy to reproduce
* the incoming data is understandable
* the downstream steps can inspect what the trigger produced
If trigger behavior is unclear, everything that follows becomes harder to debug.
## Common trigger mistakes
Watch out for these early problems:
* using a schedule when a real event trigger is a better fit
* choosing a webhook without understanding the payload structure
* using a trigger that fires more often than the workflow really needs
* assuming the trigger data will always have the same shape
* adding too many triggers before the first working path is stable
Many workflow issues look like step problems at first, but the real cause often starts at the trigger.
## What to do after adding the trigger
Once the trigger is set up:
1. inspect what data it provides
2. confirm that the data matches your expectations
3. add only the steps that depend on that input
4. run a test as early as possible
The sooner you validate the trigger, the easier the rest of the workflow becomes.
# Add steps
Source: https://workflowmachine.mintlify.app/workflows/add-steps
Build the workflow sequence by adding app actions, AI steps, and control-flow steps in a clear order.
## Steps are where the workflow does the work
After the trigger starts the workflow, steps decide what happens next.
Each step should have one clear purpose. That might be:
* calling an app action
* transforming data
* generating text with AI
* making a decision
* waiting, stopping, or routing the flow
## Build the sequence one decision at a time
The easiest way to build a workflow is to ask:
`What should happen immediately after the trigger?`
Then ask the same question again for the next step.
This keeps the workflow understandable and avoids overbuilding too early.
## Common step types
Most workflows use a mix of these step patterns:
* **App steps** to create, update, send, or fetch something from another system
* **AI steps** to summarize, extract, classify, or draft content
* **Control-flow steps** such as **If**, **Wait**, and **End**
* **Data-handling steps** that prepare the output for the next part of the workflow
You do not need every type in every workflow. Use only what helps the workflow reach its outcome cleanly.
## Keep each step focused
A step is easier to test when it does one obvious job.
For example:
* one step classifies a message
* one step creates a record
* one step sends a notification
If one step is trying to solve too many things at once, it usually becomes harder to debug later.
## Add app actions carefully
When a step talks to another app, check:
* which connection it is using
* what fields are required
* what result the app step should produce
App steps often fail because of missing permissions, incorrect field mapping, or choosing the wrong saved connection.
## Add AI steps intentionally
AI steps work best when the task is narrow and the expected output is easy to evaluate.
Examples:
* summarize this content into three bullets
* classify this request as billing, support, or sales
* extract a few specific fields from this message
If the AI task is too open-ended, the workflow becomes harder to keep reliable.
## Use control-flow steps when the workflow needs decisions
Control-flow steps are useful when:
* one path should continue only if a condition is true
* the workflow should pause before the next action
* the workflow should stop early when the input is not useful
These steps make the workflow more flexible, but they should still stay easy to explain.
## Check the handoff between steps
Every time you add a step, confirm:
* what input it receives
* which previous step produced that input
* what output it should create next
Most workflow debugging comes down to bad handoffs between steps, not broken tools.
## Keep testing as you build
Do not wait until the whole workflow is finished before testing it.
Test after meaningful additions, especially when:
* a new app step is added
* an AI step changes the data shape
* a condition branches the workflow
Short feedback loops make workflow building much easier.
# Create a workflow
Source: https://workflowmachine.mintlify.app/workflows/create-a-workflow
Start an automation from scratch, define a practical outcome, and create the first workflow draft.
## Start with a real outcome
The best workflows start with a clear result, not just a list of tools.
Before creating the workflow, decide:
* what event should start it
* what outcome should happen at the end
* how you will tell whether it worked
Good first outcomes are usually easy to verify, such as:
* sending a Slack message
* creating a row in Google Sheets
* generating a summary from incoming content
* updating a page or record in another app
If the result is easy to check, the workflow is easier to debug too.
## Create the first draft
Open [Home](https://app.workflowmachine.com/) and describe your use case in a prompt.
For example:
* `When a new form submission arrives, send a Slack alert with the lead details`
* `Every weekday morning, summarize new support emails and send a digest`
* `When a webhook is received, write the important fields into Google Sheets`
Then send the prompt to create the workflow.
Workflow Machine uses AI to turn that prompt into a starting workflow draft with the trigger and steps it thinks best match the use case.
## Start from scratch does not mean doing everything manually
Creating a workflow from scratch still does not require you to assemble every part by hand from the beginning.
The important part is that you are starting from your own use case instead of a template. The AI-generated draft is a starting point that reflects your prompt, and you can then edit it however you want.
## Name and organize the workflow clearly
Once the workflow exists, give it a name that reflects the business job it performs.
Good names describe the process clearly:
* `New lead follow-up`
* `Daily support digest`
* `Webhook to spreadsheet log`
Avoid names that only describe the tools involved. A workflow should still make sense when you revisit it later in the [Workflows](https://app.workflowmachine.com/workflows) page.
## Keep the first version practical
The goal of the first version is not to cover every edge case.
Aim for:
* one clear trigger
* one useful output
* a short set of steps
* a result you can test quickly
You can always improve the workflow after you confirm that the basic path works.
## A good first workflow shape
Most first workflows are easiest to build when they follow a simple pattern:
1. something happens
2. the workflow receives or checks the input
3. the workflow produces one useful result
If you can explain your workflow in one or two sentences, you are usually starting in the right place.
# Publish and update workflows
Source: https://workflowmachine.mintlify.app/workflows/publish-and-update
Make workflows live, understand what publishing means, and update them safely over time.
## What publish means
Publishing makes the current workflow version live.
Once a workflow is published, real trigger events can create real runs. That is the point where the workflow moves from design and testing into actual operation.
## Publish only after a successful test
The safest workflow habit is simple:
1. build the workflow
2. test it
3. publish only when the result is reliable
Publishing too early usually creates more cleanup work, not less.
## Treat published workflows carefully
A published workflow is serving a real job, so changes should be made intentionally.
If the workflow matters to your team, avoid making edits casually without thinking about:
* whether the trigger behavior is still correct
* whether the data flow has changed
* whether the connected apps or destinations are still right
* whether the next live run could behave differently
## A safe update flow
When you need to change a live workflow, this is a good pattern:
1. make the required edits
2. test the changed behavior
3. publish the updated version
4. verify the next real run
That keeps workflow changes predictable and easier to manage.
## When to republish
You should republish when a change affects the live behavior of the workflow.
Common examples include:
* changing the trigger
* changing the step sequence
* changing a condition or branch
* changing an important field mapping
* changing which connection or destination is used
If the workflow would behave differently in production, it should be republished intentionally.
## Use versions as operational history
Workflow updates are not just edits. They are part of the history of how the workflow changed over time.
That history becomes more valuable as the workflow becomes more important, because it helps you understand what changed, when it changed, and what might explain a new behavior.
## Verify after publishing
Do not stop at the publish button.
Review the next real run to make sure the workflow behaves the same way it did during testing. That final check often catches environment-specific issues and confirms the workflow is actually ready.
# Test before publishing
Source: https://workflowmachine.mintlify.app/workflows/test-before-publishing
Use tests to validate triggers, steps, and data flow before a workflow goes live.
## Why testing matters
Publishing a workflow without testing is one of the fastest ways to create avoidable failures.
Testing helps you confirm:
* the trigger is configured correctly
* app connections work
* steps run in the expected order
* data is mapped correctly between steps
## Test early, not just at the end
You do not need to wait until the workflow feels complete.
Testing earlier is usually better, especially after:
* choosing the trigger
* adding a few important steps
* connecting an external app
* adding AI logic or conditions
Short feedback loops make workflow building much less frustrating.
## Different tests answer different questions
Workflow Machine supports different kinds of testing depending on what you want to validate.
You can:
* test a single trigger
* test a single step
* test a full run using a specific trigger
Use the smallest test that answers the question you have.
## What to look for during a test
A successful test is not just “no error.”
You should also confirm:
* the right branch was taken
* the output is in the expected format
* the selected connection was correct
* the final result is actually useful
That extra review catches the kinds of issues that technical success alone does not reveal.
## Use AI to help diagnose issues
If something looks wrong, you can also use AI to help diagnose the issue and suggest what to adjust in the workflow.
That can be especially useful when:
* a prompt-based step is producing weak output
* the data mapping is confusing
* a branch is not behaving as expected
AI is not a substitute for checking the actual outputs, but it can speed up troubleshooting.
## Common causes of failed tests
Most failed tests come from:
* missing required fields
* incorrect field mapping
* invalid or wrong connections
* trigger data that does not match expectations
* AI output that does not fit the next step
When a test fails, focus first on the earliest point where the workflow behavior stops matching your intent.
## Testing builds publishing confidence
Once the workflow passes a realistic test, you are in a much better position to publish with confidence.
Testing does not guarantee perfection, but it greatly reduces the chance that the first live run will fail for a basic configuration reason.
# Use AI steps
Source: https://workflowmachine.mintlify.app/workflows/use-ai-steps
Add AI steps for summarization, extraction, classification, and drafting without making the workflow harder to trust.
## Where AI steps help most
AI steps are most useful when the workflow needs to handle text, messy input, or judgment-like tasks that are difficult to solve with rigid rules alone.
Strong use cases include:
* summarizing long messages or documents
* extracting structured details from unstructured text
* classifying incoming requests
* drafting replies, alerts, or updates
## Give each AI step one clear job
AI works best when the task is specific.
For example:
* `Summarize this message into 3 bullet points`
* `Classify this request as billing, support, or sales`
* `Extract name, company, and urgency from this email`
That is usually more reliable than asking one AI step to do several unrelated things at once.
## Use AI inside a structured workflow
The most practical way to use AI is as one part of a larger automation.
For example:
1. a trigger receives new input
2. an AI step summarizes or classifies it
3. later steps route, notify, or store the result
This keeps the workflow structured even when the input is unstructured.
## Common AI step patterns
The most useful prompt-based patterns are usually:
* **Summarization** for digests, notes, or shorter overviews
* **Classification** for routing or labeling work
* **Extraction** for turning text into fields
* **Drafting** for creating suggested replies, updates, or descriptions
Start with one pattern at a time before combining them.
## Keep the output easy to evaluate
Before adding an AI step, ask:
* what exact output should this step produce
* how will I know whether the result is good enough
* what downstream step depends on this output
If the expected output is vague, the workflow becomes much harder to troubleshoot.
## How to keep AI steps reliable
These habits usually help most:
* keep the prompt task narrow
* describe the expected output clearly
* test with realistic examples
* inspect the output before sending it into later steps
* prefer normal logic when a deterministic rule would work better
AI is most valuable where it adds flexibility, not where it replaces simple predictable logic.
## Improve the prompt by tightening it
If an AI step is useful but inconsistent, the best next move is usually to make the task more precise.
Stronger prompts usually come from:
* removing extra instructions
* narrowing the scope
* clarifying the output format
* using better example inputs during testing
That is usually more effective than making the prompt longer and more complicated.
# Use conditions and branches
Source: https://workflowmachine.mintlify.app/workflows/use-conditions-and-branches
Control workflow behavior with conditions, branching, waiting, and early exits.
## Not every workflow should do the same thing every time
Many automations need to make decisions based on the input they receive.
Examples:
* continue only if a record meets certain criteria
* route different requests to different destinations
* stop early when required data is missing
* wait before taking the next action
That is where conditions and control-flow steps become useful.
## Use branching when the workflow outcome depends on the input
Branching is a good fit when one workflow needs multiple possible paths.
Use it when the workflow should ask:
* is this important enough to continue
* where should this be routed
* should it be handled one way or another
This is usually better than creating several almost-identical workflows that differ only by one rule.
## Keep condition logic easy to explain
A good branch should make sense in one sentence.
For example:
* if the lead is high intent, notify sales
* if the message is low priority, store it without alerting anyone
* if required data is missing, stop the workflow
If the condition is hard to explain, it may be too complex for the current version of the workflow.
## Use wait steps intentionally
Wait steps are helpful when:
* a downstream system needs time before the next action
* the workflow should delay a follow-up
* the process should pause between stages
Use waits because the business process needs them, not because the workflow logic is unclear.
## End early when continuing would waste work
Sometimes the best result is to stop the workflow.
That is useful when:
* the input is incomplete
* the record does not meet the workflow criteria
* the result would not be useful enough to keep processing
Ending early is often cleaner and cheaper than letting unnecessary steps run.
## Design for predictable outcomes
When adding conditions, optimize first for:
* readability
* predictable behavior
* easy testing
You can always make the logic more sophisticated later. Branches that are too clever too early are harder to maintain.
## Test each branch deliberately
Do not assume the branch logic is correct just because one path worked.
Where possible, test:
* the true path
* the false path
* the early exit behavior
* any wait or delayed behavior that matters to the workflow
Branching is most trustworthy when each possible path has been checked intentionally.
# Use schedules
Source: https://workflowmachine.mintlify.app/workflows/use-schedules
Run workflows on a recurring schedule for digests, checks, syncs, and other time-based automations.
## When a schedule is the right trigger
Use a schedule when time is what should start the workflow.
This is a strong fit for:
* daily or weekly summaries
* recurring syncs
* periodic checks
* reminder-style automations
If the workflow exists to run at a particular time or interval, a schedule is usually the right starting point.
## Common schedule patterns
Scheduled workflows often work well for:
* weekday digests
* end-of-day summaries
* weekly reviews
* regular data sync jobs
* reminder workflows that run at fixed intervals
The simpler the timing, the easier the workflow is to reason about later.
## Match the schedule to the real need
Choose a frequency that fits the process.
Ask:
* does this need to run hourly, daily, or weekly
* will running too often create noise or unnecessary usage
* is the workflow still useful at that cadence
A schedule that is too aggressive can waste credits and make the workflow harder to trust.
## Keep scheduled workflows practical
The fact that a workflow runs on a timetable does not mean it should be large or complicated.
As with other workflows, it is usually better to start with:
* one clear schedule
* one clear output
* a short sequence of steps
Then refine the workflow after you have seen real runs.
## Test the workflow before relying on the schedule
Do not assume a scheduled workflow is correct just because the timing looks right.
Test:
* the step sequence
* the output
* any app connections
* any AI or branching behavior
Once the workflow logic is stable, the schedule can handle the recurring execution.
## Check scheduled workflows over time
Scheduled workflows are easy to forget because they run in the background.
Review their runs periodically to confirm:
* they are still producing useful output
* they are not firing more often than intended
* downstream systems have not changed in a way that breaks them
The value of a scheduled workflow comes from consistent behavior over time, not just one successful run.
# Use webhooks
Source: https://workflowmachine.mintlify.app/workflows/use-webhooks
Use webhook triggers to start workflows from external systems and custom events.
## Why webhooks are useful
Webhooks are one of the most flexible ways to start a workflow.
They let another system send data directly into Workflow Machine, which makes them useful when:
* you are integrating with a custom app
* you need an event-driven trigger from another system
* there is no native app trigger for the source
## When to choose a webhook
Use a webhook when the natural shape of the process is:
`Something happens elsewhere, and that system sends data into this workflow.`
Typical webhook use cases include:
* form submissions from external tools
* internal app events
* service-to-service notifications
* custom operational systems
## Design the payload carefully
The more predictable the incoming webhook data is, the easier the rest of the workflow becomes.
When planning a webhook workflow, decide:
* which fields are always present
* which fields are optional
* what downstream steps actually need
* what shape later steps expect
Good payload design reduces troubleshooting later.
## Keep webhook usage secure
Because webhooks accept external input, be deliberate about who can send data and what the workflow does with that data.
Good habits include:
* sending only the fields you need
* avoiding overly broad payloads
* being careful with sensitive data
* treating the webhook URL like a credential
Even when the workflow goal is simple, the input path should still be handled carefully.
## Test webhook payloads early
Webhook workflows should be tested as soon as the trigger and first downstream steps exist.
Testing should confirm:
* the webhook reaches the workflow
* the payload shape matches expectations
* downstream steps can use the incoming data correctly
Webhook issues are usually easiest to fix at the input stage, before the workflow grows more complex.
## Common webhook mistakes
Watch for these problems:
* assuming fields will always be present
* sending more payload data than the workflow really needs
* skipping payload testing before adding several downstream steps
* treating a webhook like a generic solution when a native app trigger would be clearer
The better the incoming payload is defined, the more reliable the workflow becomes.
## A good first webhook workflow
If you want a simple first webhook workflow, start with:
* one webhook trigger
* one small processing step
* one visible output such as Slack or Google Sheets
That gives you a fast feedback loop without too much moving complexity.
# Work with data between steps
Source: https://workflowmachine.mintlify.app/workflows/work-with-data-between-steps
Pass data through a workflow cleanly so each step receives the information it actually needs.
## Most workflow problems are data-flow problems
The trigger may be correct and the step may be valid, but the workflow can still fail if the wrong data is passed between steps.
That is why working with data between steps is a core workflow skill.
## Start from the trigger output
The trigger is usually the first source of data in the workflow.
Before adding several downstream steps, understand:
* what fields the trigger provides
* which of those fields are actually useful
* what later steps will need
This helps you avoid depending on data that is not reliable or necessary.
## Reference previous step outputs deliberately
Every step should know where its input is coming from.
For each step, ask:
* which previous step produced this value
* is that value always present
* does the next step need the raw value or a cleaned-up version
That keeps the workflow easier to understand and easier to troubleshoot.
## Pass only what the next step needs
A good workflow handoff is small and intentional.
Try not to map every available field just because it exists. Pass the values that the next step actually needs to do its job.
This keeps the workflow simpler and reduces confusion later.
## Expect data shapes to change
Different steps may return data in different formats.
That is especially common when:
* an AI step rewrites or summarizes content
* an HTTP request returns nested data
* one app expects fields that another app does not use
Whenever the data shape changes, confirm the next step still knows how to use it.
## Use templates and expressions carefully
Templates and expressions are useful for shaping values, combining fields, or formatting output for the next step.
Start simple:
* reference one field at a time
* confirm the output shape during testing
* only add more complex logic after the basic mapping works
Complex expressions are easier to manage once the base data flow is already stable.
## Inspect real outputs during tests
The best way to understand workflow data is to inspect actual step outputs during tests and runs.
Do not rely only on assumptions about what a step should return. Check what it actually returns in practice.
## Keep the chain easy to explain
If you can describe the data flow in plain language, the workflow is usually in good shape.
For example:
* webhook sends lead details
* AI step classifies the lead
* Slack step sends the summary to sales
That is much healthier than a workflow where it is no longer clear which step created which value.