Amazon Bedrock Flows: GenAI workflows you draw instead of code.
Bedrock Flows is a drag-and-drop builder for multi-step generative-AI workflows. This page covers the node types, how a workflow is wired, when a Flow beats code, how to ship and debug one, its limits, and what it costs.
- Amazon Bedrock Flows is a visual builder for generative-AI workflows. You drop steps (prompt, knowledge base, agent, Lambda, condition, loop) on a canvas as nodes and connect them. The diagram is the program, and you call it through the Bedrock API.
- Flows is faster than LangChain or Step Functions for GenAI-shaped pipelines and easy for non-engineers to read. The trade-off is a fixed node set. Anything custom goes through a Lambda node, and heavy backend logic belongs in code.
- You ship a Flow by publishing a version and pointing an alias such as "prod" at it. A Flow costs the sum of the work its nodes do (model tokens, retrieval, Lambda, S3). A vetted AWS partner can file POC or IW funding for that work when it qualifies and AWS approves.
IWhat Amazon Bedrock Flows is
Bedrock Flows is the visual orchestration layer of Amazon Bedrock. You assemble a multi-step generative-AI workflow from pre-built nodes on a canvas instead of writing the glue code.
A useful GenAI feature is rarely one model call. It is a sequence of steps: take input, look something up in your documents, run a prompt, branch on the result, call a tool, maybe loop over a list, then return an output. You can write that orchestration in code with LangChain or wire it with Step Functions. Flows lets you draw it: each step is a node, and you connect one node's output to the next node's input.
The nodes are GenAI-native and already wired into Bedrock. A prompt node is a configured model call. A knowledge-base node is a managed RAG retrieval. An agent node invokes a Bedrock Agent that can use tools. Data passes between them automatically, so a workflow that would be a few hundred lines of code becomes a diagram you can build and read in an afternoon.
A Flow has an input and one or more outputs. You invoke a finished Flow through the Bedrock API (the InvokeFlow operation), so it slots into an application the same way a single model call does. See the Bedrock Flows user guide.
Flows sits next to the rest of the Bedrock toolkit. Agents handle open-ended steps where the model decides which tools to call. Knowledge Bases handle managed RAG. Prompt Management stores and versions prompts. Flows composes these into an explicit pipeline with control flow you define, and it can use all of them as nodes.
IIThe node types
A Flow is built from a fixed set of node types. Knowing what each one does is most of knowing what Flows can build.
Every Flow starts with an input node and ends with one or more output nodes. In between you compose from the nodes below. Each node's settings reference the outputs of the nodes that feed into it.
- Prompt node: A configured model call. Pick a model and write a prompt template whose variables are filled from upstream outputs. You can reference a prompt from Prompt Management or define it inline.
- Knowledge base node: Runs a retrieval against a Bedrock Knowledge Base. It can return chunks for a downstream prompt or retrieve and generate a grounded answer directly.
- Agent node: Invokes a Bedrock Agent for a step that needs multi-turn tool use rather than one fixed prompt.
- Lambda function node: Calls one of your Lambda functions. This is the escape hatch for external APIs, data transforms, database calls and business logic.
- Condition node: Branches the workflow on upstream data, like an if/else or switch. For example, send easy requests to a cheap model and hard ones to a frontier model.
- Iterator and collector nodes: The iterator runs downstream steps once per item in a list; the collector gathers the results into one output.
- S3 nodes: Read an object from S3 into the workflow, or write a node's output to S3.
- Lex node: Connects an Amazon Lex bot so a chat or voice front end can drive the Flow.
The palette is fixed but composable. You cannot add a node type, but the Lambda node covers anything the built-in nodes do not. AWS adds nodes over time, so check the current list in the Bedrock documentation when you design a Flow.
IIIBuilding a multi-step workflow
In the Bedrock console you open the Flow builder, drag nodes onto the canvas, configure each one, and draw connections between them. The connections are the data flow.
Example: a content pipeline
Input (a topic) → knowledge base (retrieve internal research) → prompt (draft using that context) → condition (does the draft pass a quality check?) → if not, route to a stronger model; if yes → a second prompt (edit) → S3 (save) → output. Retrieve, draft, check, refine and store become a handful of connected boxes.
Example: multi-model routing
A prompt node tags each request by difficulty, a condition node branches on the tag, and each branch is a prompt node bound to a different model: a cheap model for easy requests and a frontier model for hard ones. The router is visible and auditable.
Example: document processing with an iterator
An input or S3 node supplies a list of documents, an iterator runs the same extraction steps on each one, and a collector gathers the results into one array for the output.
IVFlows vs orchestration in code (LangChain, Step Functions)
Both are legitimate. The choice turns on flexibility, who maintains the workflow, and how GenAI-specific it is.
LangChain (and LlamaIndex) are code libraries for chaining LLM calls, tools and retrieval in your own codebase. AWS Step Functions is a general workflow service for any AWS work. Flows sits between them: visual like Step Functions, with GenAI-native nodes like LangChain, and fully managed inside Bedrock.
Flows wins on speed to build a GenAI pipeline, readability, and no infrastructure to run. Code wins on flexibility, testing with your normal tooling (unit tests, diffs, CI), and workflows that are mostly backend logic. Step Functions wins for broad operational pipelines (long jobs, human approval steps, fan-out across services) where GenAI is one stage.
Rule of thumb: a chain of GenAI steps → a Flow, with a Lambda node for the odd custom piece. Deep custom logic or strict testing needs → code. A large pipeline where GenAI is one stage → Step Functions, which can still call a Flow. Many systems mix them.
VVersions, aliases, testing and tracing
Flows uses the same versions-and-aliases model as Lambda and Bedrock Agents, plus a test panel with tracing in the console.
Versions and aliases
You edit a working draft. When it is ready you publish an immutable, numbered version. An alias such as prod points at one version, and your application calls the alias. To release, repoint the alias to the new version; to roll back, point it back. You can keep editing the draft without touching what production runs.
Testing and tracing
The builder has a test panel where you run the Flow on sample input. Turn on trace to see what each node received and returned, which branch a condition took, and where tokens went. That is how you find the node that produced a bad result. Flow invocations also feed AWS logging and monitoring for production.
| Artifact | What it is | Mutable? | What you do with it |
|---|---|---|---|
| Working draft | The Flow you are editing | Yes | Build and test changes |
| Version | Published immutable snapshot | No | Freeze a tested release |
| Alias | Named pointer to a version (e.g. prod) | Yes (repoint) | What your app invokes; promote or roll back |
VIUse cases and limitations
Flows fits a specific shape of problem. Knowing where it does not fit saves you a rebuild in code later.
Good fits
Content pipelines (retrieve, draft, check, refine, publish). Multi-model routing to control cost. Document processing with the iterator pattern. Chatbot back ends driven by a Lex node. And prototyping any GenAI workflow, even if you later move it to code.
Limits to design around
The node set is fixed: a Flow that is mostly Lambda nodes probably belongs in code. Flows is for orchestration, not heavy computation, so push large transforms and long batch jobs to other services. Deeply nested branching gets hard to read on a canvas. Latency-critical or very high-throughput paths may need hand-tuned code. Quotas and the node list change, so check the Bedrock documentation before you commit a production workflow.
VIIWhat Flows costs, and who can fund the build
Flows itself is not the expensive part. The work it orchestrates is.
There is generally no separate fee for the visual builder. A run costs what its nodes do: Bedrock per-token cost for prompt and agent nodes, retrieval cost for knowledge-base nodes, Lambda cost for Lambda nodes, and S3 request and storage cost for S3 nodes. The cost levers are the usual Bedrock ones: right-size the model in each prompt node, cache stable prompts, and avoid needless expensive branches.
That spend draws down AWS credits automatically. There are two ways to get funding for it. Partner-filed funding: a vetted AWS partner can file POC (proof of concept) funding to test the workflow, or incremental workload (IW) funding if you already run on AWS and this is new work. For startups this is typically $50K to $150K. Depends on the workload; AWS approves.
AWS Activate: you apply yourself. Activate Founders gives self-funded startups $1,000 to start, up to $5,000. Activate Portfolio gives up to $200,000 with the Org ID from your VC, accelerator or angel group, if it is an Activate Provider. A consulting partner cannot file Activate for you.
CloudRoute matches you with one vetted AWS partner who can build the Flow and check which funding fits. Startups pay CloudRoute nothing. Partners pay CloudRoute a monthly membership plus 10% of AWS-approved funding.
| Funding | Who files it | Amount | When it fits |
|---|---|---|---|
| Migration Acceleration Program (MAP) | Your matched AWS partner | $50K to $150K for startups. Depends on the workload; AWS approves. | You are not on AWS yet and want to migrate. |
| Proof of concept (POC) funding | Your matched AWS partner | $50K to $150K for startups. Depends on the workload; AWS approves. | You want to test something, whether or not you are on AWS today. |
| Incremental workload (IW) funding | Your matched AWS partner | $50K to $150K for startups. Depends on the workload; AWS approves. | You are already on AWS and are launching new work: a new AI feature, a new customer or a new contract. |
| AWS Activate Founders | Founder applies | $1,000 to start, up to $5,000 | Self-funded startups with no investor or accelerator behind them. |
| AWS Activate Portfolio | Founder applies | up to $200,000 | Startups backed by a VC firm, accelerator or angel investor that is an AWS Activate Provider. |
| AWS Credits for AI Startups | Invite only (AWS account manager) | $200,000 or more, by invitation | AI startups ready to scale after Activate Portfolio, invited by AWS. |
Bedrock Flows vs Bedrock Agents vs Step Functions
Three orchestration options that overlap but solve different problems. Flows can use an Agent as a node, and Step Functions can invoke a Flow.
| Dimension | Bedrock Flows | Bedrock Agents | AWS Step Functions |
|---|---|---|---|
| What it is | Visual GenAI workflow builder | Tool-using GenAI component | General-purpose workflow orchestrator |
| Interface | Drag-and-drop canvas | Configured agent (instructions + tools) | Visual + JSON state machine |
| Control flow | You define it (nodes and links) | The model decides at run time | You define it (states and transitions) |
| GenAI-native? | Yes: prompt, KB and agent nodes | Yes | No: orchestrates any AWS work |
| Best for | Multi-step GenAI pipelines | Open-ended tasks with dynamic tool use | Broad AWS pipelines; GenAI as one stage |
| Who can build it | Engineers and non-engineers | Engineers | Engineers and cloud teams |
| Custom code | Lambda node | Action groups (Lambda or APIs) | Lambda and service integrations |
How a match works (example)
- You tell us about the work
You fill in a short form: what you run today, what you want to move, test or build, your stage and your region.
- We pick one partner
We read your answers and pick one vetted AWS consulting partner that fits the work, the stack and the region. We reply within 24 hours; your matched partner reaches out within 5 business days.
- The partner checks POC funding
Your matched partner scopes the test with you. Then it checks whether the test qualifies for POC (proof of concept) funding. A POC can fit whether or not you run on AWS today.
- The partner files, AWS decides
If the work qualifies, the partner files the funding request with AWS. AWS reviews it and decides. The amount depends on the workload.
- You pay nothing
CloudRoute is free for startups. Partners pay CloudRoute a monthly membership plus 10% of AWS-approved funding.
AWS Activate credits are separate, and you apply for them yourself. Use Activate Founders if no investor backs you. Use Activate Portfolio with the Org ID or invite from your VC, accelerator, incubator or angel group if it is an Activate Provider. A consulting partner cannot apply for Activate on your behalf.
Common questions
What is Amazon Bedrock Flows?
What node types can a Bedrock Flow contain?
How is Bedrock Flows different from Bedrock Agents?
Should I use Bedrock Flows or write orchestration in code?
How do versions and aliases work in Bedrock Flows?
Can I test and debug a Bedrock Flow?
What are the limitations of Bedrock Flows?
How much does Bedrock Flows cost, and can AWS funding cover it?
Build the GenAI workflow with a partner who can file the funding
A vetted AWS partner can design the node graph, wire the knowledge-base and agent nodes, write the Lambda steps and set up versions and aliases. The same partner checks whether the work qualifies for POC or IW funding: typically $50K to $150K for startups. Depends on the workload; AWS approves. CloudRoute is free for startups.