# Workflow Builder

> Workflow Builder is a React SDK for embedding visual workflow editors into B2B SaaS products. It provides a production-ready editor UI (canvas, nodes, edges, schema-driven properties panel) built on React Flow, with JSON serialization. Unlike n8n or Flowise, Workflow Builder is not an automation platform — it is the embeddable UI layer you integrate into your own product. Available as open-source (Community, Apache 2.0) and commercial (Enterprise, €6,990 one-time). Built by Synergy Codes.

This file contains the full content of key pages from workflowbuilder.io, formatted as markdown for LLM ingestion. For a concise overview with links, see: https://www.workflowbuilder.io/llms.txt

Last updated: 2026-08-19

## Contents

- Homepage — product overview, features, build-or-buy comparison, case studies
- For Developers — developer-focused pitch, integration path, tech comparison
- Pricing — Community (€0) vs Enterprise (€6,990), feature breakdown
- FAQ — 34 questions across 4 categories (developers, implementation, licensing, consulting)
- Compare: Workflow Builder vs n8n — positioning, pricing, feature comparison, FAQ
- Documentation Overview — scope, key features, typical use cases
- AI Agent Workflows — code-first AI agents, reference back-end, Temporal integration, FAQ
- Build vs Buy — cost math (React Flow build vs SDK vs SaaS), decision framework, case studies, FAQ
- Compare: Workflow Builder vs ActivePieces — React SDK vs iPaaS, pricing, feature comparison, FAQ
- Compare: Workflow Builder vs Dify — React SDK vs LLMOps platform, license restrictions, FAQ
- Compare: Workflow Builder vs Flowise — React SDK vs LangChain.js studio, open-core split, FAQ
- Compare: Workflow Builder vs Langflow — TypeScript SDK vs Python/IBM watsonx studio, FAQ
- Open Source — Apache 2.0 scope, license footprint, why Apache 2.0, GitHub presence, FAQ
- Reference Stack — open-source orchestration reference architecture (three apps, three ports), engine-swap, FAQ
- Temporal Integration — visual authoring layer on top of Temporal, architecture, quick start, FAQ
- LangGraph Integration — visual canvas for code-first LangGraph agents, architecture, quick start, FAQ
- Call Flow Builder (CPaaS / CCaaS) — embedded call flow editor, React Flow scale thresholds, four scenarios, fit criteria, FAQ
- Marketing Automation Workflows (Martech) — embedded journey/campaign canvas, five product types, build-vs-buy, integration steps, FAQ

---

# Homepage
Source: https://www.workflowbuilder.io/

## Workflow Builder — React SDK for Embedding Production-Ready Workflow Editors

Ship a working workflow editor in days, not months. Drag-and-drop nodes, TypeScript, JSON output, backend-agnostic.

Stop building workflow editors from scratch. Get a production-ready editor with nodes, canvas and configuration panels built in. Adapt UI and behavior using design tokens and React components. Connect to your backend and go live.

### Testimonial

> Workflow Builder gave us a complete, proven foundation — architecture, UX patterns, interaction design — all solved. Our team went straight to building what's unique about our product instead of reinventing the wheel. That saved us roughly €50,000 and months of trial and error. The team behind it made the real difference.

— Adam Lewkowicz, CTO at MessageFlow

### Trusted By

Chosen by startups shipping fast and enterprises building with confidence. We've powered workflows at startups, fintechs, and Fortune 500s.

Featured clients: Zeenea, Druid, Canon, Metricus, y42, Siemens, EonCollective, BMW, CodeSee, Hanwha, Autoliv, Reglynk, TotalEnergies.

### Key Features

**Visual Workflow Canvas** — A scalable, infinite workspace for designing automation workflows using drag-and-drop interactions. Users can create, organize, and connect nodes visually without writing code, which accelerates implementation and improves clarity for both technical and non-technical users.

**Node Library** — A ready-to-use set of workflow building blocks, including triggers, business actions, condition logic, branching rules, and time-delay elements. Each node can be extended, themed, or replaced with a custom component, enabling domain-specific automation editors.

**Dynamic Properties Panel** — Every node and edge has a contextual configuration panel that automatically renders dynamic forms based on JSON schema. This allows teams to define data inputs, parameters, rules, and validation logic without modifying UI code — perfect for evolving products and multi-tenant systems.

**Auto-save Functionality** — Automatically persist workflow changes without interrupting the user experience. The system saves data in the background before the user exits the application, preventing accidental data loss. Supports both local storage and API-based persistence, making it suitable for prototypes as well as production-grade, multi-user environments.

**Read-only Mode** — A dedicated viewing mode for users without edit permissions. All nodes and connections on the canvas are locked, preventing modifications while still allowing full inspection of node properties and workflow structure. Ideal for stakeholders, reviewers, and audit or approval scenarios.

**Flow Runner** — The Flow Runner traverses the workflow graph and executes functions defined for each node type. It handles async operations (waiting for API calls, user input, timers), supports step-by-step execution with pause and resume, manages branching logic through decision and condition nodes, and propagates data between connected nodes.

**Zoom In / Out** — Navigate workflows with precision at any scale. Users can zoom in for detailed editing or zoom out to understand the broader process structure. Zooming is controlled via dedicated UI actions, making it easy to work comfortably with both small diagrams and large, enterprise-level workflows.

**Auto-Layout** — Organize diagrams automatically with auto-layout. Nodes and edges are positioned cleanly, even in complex flows. Supports multi-handle routing and label alignment — no manual adjustments required.

**Smart Edge Routing — Avoiding Collision with Nodes** — Create structured, right-angled connections between nodes for maximum diagram readability. Orthogonal edges automatically route paths using horizontal and vertical segments, keeping workflows clean and easy to follow even as complexity grows. Especially useful for enterprise workflows where alignment and visual order matter.

**Edge Reshaping** — Adjust and fine-tune orthogonal edge paths directly on the canvas using interactive handles. Users can reshape connections to avoid overlaps, improve readability, or align flows manually — all while preserving logic. Fully supports node rotation and grouped structures, enabling precise layout control in complex diagrams.

### Build or Buy?

You don't need to build from scratch or embed an off-the-shelf platform. You can start with a workflow interface you own and extend.

Workflow Builder is a white-label visual layer you embed into your product — or use as a foundation for a standalone application. You own the frontend source code. You control execution, pricing, and limits. No vendor lock-in, no forced backend. Workflow Builder adapts to your architecture — not the other way around.

### Comparison: Workflow Builder vs External Platform vs Build In-House

| Aspect | Workflow Builder | External Platform | Build In-House |
|--------|------------------|-------------------|-----------------|
| What you embed | Workflow editor UI (frontend SDK) | Full platform (UI + execution runtime) | Everything you need |
| Best fit when | Workflow and UX is a core and strategic product capability that must be fully customizable and scalable | You need ready-made interface for relatively standard scenarios | Your requirements are highly unique and justify custom development |
| Implementation complexity | Low — structured SDK with built-in diagram patterns and extensible architecture | Medium–High — platform concepts, APIs, constraints | Very high — requires mastering diagram domain concepts, state management, UX, layouts, and performance |
| Time to market | Fast — production-ready editor | Fast for standard scenarios | Slow — building from scratch |
| UX maturity | High — built with 15+ years of diagram UX expertise | Good, but platform-driven | Depends on internal team experience |
| UX customization | Full control — white-label, design system included | Limited to platform constraints | Full (high effort) |
| Design system & UI | Included — ready-to-use design system & design tokens | Limited or not typically available | Build from scratch. Requires Diagram UX expertise. |
| Extensibility & future growth | Full — React source code, plugin-based architecture | Limited — APIs & config rules | Full (high engineering cost) |
| Execution & logic | Connect to your own backend execution | Vendor or self-hosted runtime | Your backend |
| Integrations | Depends on the workflow engine you use | Prebuilt integrations included | Built from scratch |
| Main trade-off | You own execution | Platform lock-in | Time, cost, and risk. Requires mastering diagram domain |

### ROI / TCO

**Workflow Builder:** Time to market: Days. Up front cost: Community: Free (Open Source), Enterprise: €6,990 one-time. Pricing model: One-time license fee (Enterprise), Open-source Community edition. Ownership: Full — OSS or perpetual license.

**External Platform:** Time to market: Fast initial setup. Up front cost: e.g. n8n starts from ~$50,000/year. Pricing model: Subscription/contract-based. Ownership: Platform-dependent.

**Build In-House:** Time to market: Slow — ~700+ engineering hours & ~300+ design hours. Up front cost: €50,000–€70,000 (initial build). Pricing model: Internal engineering cost. Ownership: Full.

### Case Studies

**Adding a production-ready workflow UI in 1 day** — Athena Intelligence skipped months of dev time by integrating our white-label workflow UI in a single day.

**Plura AI fast-tracks QA and client onboarding** — With flexibility built in, Workflow Builder enabled Plura AI to move faster and adapt to evolving requirements.

### Figma Kit

Design your workflow interface — before writing a single line of code. Workflow Builder comes with a dedicated Figma Kit that mirrors every part of the final interface. Your designers can map out entire workflow editors visually, while developers reuse the same components in production.

### Who We Are — Diagramming Experts

- Experts in diagram-based solutions — 15+ years of building, scaling, and optimizing workflow and automation interfaces.
- 200+ custom workflow tools delivered across industries — from early-stage startups to global enterprises.
- Comprehensive consulting support — audits, product discovery, product strategy, and UX for complex workflow systems.
- End-to-end product development — from architecture and front-end engineering to customization and integrations.

Expert-driven foundation with an open-source core, built by world-class experts in diagramming, automation, and configuration tools — combining real-world enterprise experience with the flexibility of open source.

**Community Edition** — A lightweight open-source edition for experimentation, prototyping, and learning. Ideal for developers exploring workflow UI concepts before moving to full-scale implementations.

**Enterprise Edition** — A production-ready, fully supported version built for organizations that need reliability, performance, and long-term scalability. Includes advanced features, dedicated support, customization options, and integration paths for real-world systems.

---

# For Developers
Source: https://www.workflowbuilder.io/for-developers

## Developer-first workflow UI toolkit for React

Your foundation for building workflow editors — fast.

Workflow Builder gives you a full front-end environment built with React, TypeScript, and React Flow. Connect the SDK to your stack and ship custom workflow editors that look and behave like they were built in-house.

### Your Challenge

Every developer knows this pain:

- You're asked to build workflow features, but most of your time goes into wiring the basics — drag & drop, layout, state.
- SaaS tools look tempting until you hit a wall with customization.
- Stakeholders want results yesterday, but you're buried in boilerplate instead of solving real product problems.
- Building from scratch adds months of tech debt.
- Buying SaaS means you're stuck with a black box.

Neither feels like a win.

Workflow Builder gives you a third way: a front-end toolkit that does the boring part, stays open, and keeps you in control.

### What You Get

You don't need to rebuild workflows from scratch. We've done the boring part.

**Skip the boilerplate** — Spin up a working editor in minutes. Ready-to-use nodes, edges, and auto-layout logic turn months of setup into days.

**Back-end agnostic** — Connect to your stack with zero lock-ins. REST APIs, databases, or AI pipelines — Workflow Builder adapts to whatever architecture you already run. No hidden dependencies. No forced hosting.

**Full control** — Own the code. White-label every layer — from UI to node behaviors — and extend modules freely. Workflows look and feel like your product, not someone else's.

**Plugin-first architecture** — Extend functionality with a clean plugin system. Add new features or integrations without touching the core. Scalable, maintainable, future-proof.

**Production-ready** — Deploy on your own infrastructure with full control over security and compliance. Docs, quickstarts, and an open roadmap help you ship with confidence, at any scale.

**Branding & design system** — Style workflows to match your brand or your clients'. Our components, tokens, and themes connect directly to Figma — so exporting brand colors and assets takes seconds.

**Easy node configuration** — Add or tweak workflow objects without touching code. Your product or ops teams can expand the node palette through config, while you focus on actual development.

### Key Features

**Visual Workflow Canvas** — A scalable, infinite workspace for designing automation workflows using drag-and-drop interactions without coding.

**Node Library** — A ready-to-use set of workflow building blocks, including triggers, business actions, condition logic, branching rules, and time-delay elements. Each node can be extended, themed, or replaced with a custom component, enabling domain-specific automation editors.

**Dynamic Properties Panel** — Every node and edge has a contextual configuration panel that automatically renders dynamic forms based on JSON schema.

**Auto-Layout** — Organize diagrams automatically with auto-layout. Nodes and edges are positioned cleanly, even in complex flows. Supports multi-handle routing and label alignment.

**Smart Edge Routing — Avoiding Collision with Nodes** — Create structured, right-angled connections between nodes for maximum diagram readability. Orthogonal edges automatically route paths using horizontal and vertical segments.

**Flow Runner** — The Flow Runner traverses the workflow graph and executes functions defined for each node type. It handles async operations, supports step-by-step execution with pause and resume, manages branching logic, and propagates data between connected nodes.

**Edge Reshaping** — Adjust and fine-tune orthogonal edge paths directly on the canvas using interactive handles.

**Auto-save Functionality** — Automatically persist workflow changes without interrupting the user experience. Supports both local storage and API-based persistence.

**Read-only Mode** — A dedicated viewing mode for users without edit permissions.

**Zoom In / Out** — Navigate workflows with precision at any scale.

### How It Works — 4-Step Path

1. **Download** — Download repository and embed it into your codebase.
2. **Customize** — Configure your nodes library and JSON schema for properties to adapt to your use case, turn on or off required features.
3. **Connect** — Connect the workflow output with the API or workflow engine of your choosing.
4. **Deploy** — Run in your CI/CD, self-host on your infrastructure.

### Comparison: Workflow Builder vs External Platform vs Build In-House

| Category | Workflow Builder | External Platform | Build In-House |
|----------|------------------|-------------------|-----------------|
| Best fit when | Workflow and UX is a core and strategic product capability that must be fully customizable and scalable | You need ready-made interface for relatively standard scenarios | Your requirements are highly unique and justify custom development |
| Architecture model | Frontend-only SDK | Embedded platform | Fully custom |
| Embedded layer | UI / editor only | UI + execution engine | Fully custom |
| Implementation complexity | Low — structured SDK with built-in diagram patterns and extensible architecture | Medium–High — platform concepts, APIs, constraints | Very high — requires mastering diagram domain concepts, state management, UX, layouts, and performance |
| Ability to modify core UX | Full | Limited to platform customization | Full |
| Source code access | Yes — React source code | No | Yes |
| Extensibility | High — plugin-like architecture | APIs, configs, platform rules | Unlimited (engineering effort required) |
| Diagram UX expertise | Built-in — battle-tested patterns | General-purpose UX | Must be developed |
| Performance & scalability | Optimized editor layer | Platform-dependent | Team-dependent |
| UX customization | Full — nodes, panels, interactions | Limited | Full |
| Design system | Provided (Figma Kit + tokens) | Not provided | Build from scratch |
| Execution engine | Your backend | Platform or self-hosted | Your backend |
| Integrations | Depends on the workflow engine you use | Prebuilt integrations | Built from scratch |
| Upgrade & maintenance | Full ownership over source code | Platform dependency | Full ownership |
| Vendor lock-in | Low — you own the source code | High | None |

### Community

Built in the open. Designed for developers. Workflow Builder started as an open-source project — and it stays that way. Join our developer community on Discord and GitHub to explore the Community Edition, share ideas, and help shape the roadmap.

### Design System

Build workflows faster with design-ready components. Workflow Builder includes a production-ready React component system that mirrors the Figma Design Kit. Designers define the workflow visually, while developers implement the same components in code.

### Pricing

Think of licensing as buying engineering time back. While Community edition is free, the Enterprise is one predictable cost which replaces months of setup, scaffolding, and maintenance. No per-seat surprises, no API call limits, no hidden meters.

**Community Edition — €0** — A lightweight open-source edition for experimentation, prototyping, and learning.

**Enterprise Edition — €6,990** — A production-ready, fully supported version built for organizations that need reliability, performance, and long-term scalability.

---

# Pricing
Source: https://www.workflowbuilder.io/pricing

## Build your workflow app in days, not months

### Pricing Plans

Choose the plan that fits your needs — from Community to fully customized Enterprise solutions.

### Community Edition — €0

A lightweight open-source edition for experimentation, prototyping, and learning.

Features:
- Basic features set
- Full documentation access

### Enterprise Edition — €6,990 / one-time payment

A production-ready, fully supported version built for organizations that need reliability, performance, and long-term scalability.

Features:
- Everything from Community Plan
- Advanced features
- Priority support
- Custom development
- Customization options
- Integration paths for real-world systems

### Features Across All Plans

#### Community Edition Features

**Visual Workflow Canvas** — A scalable, infinite workspace for designing automation workflows using drag-and-drop interactions without coding.

**Node Library** — Example nodes including triggers, actions, conditionals, decisions, and AI-powered options serving as extensible reference implementations.

**Dynamic Properties Panel** — Contextual configuration panels rendering dynamic forms based on JSON schema for data inputs and validation.

**Auto-save Functionality** — Background persistence supporting local storage and API-based solutions for multi-user environments.

**Read-only Mode** — Dedicated viewing mode with locked nodes and connections for stakeholders and audit scenarios.

**Zoom In/Out** — Navigation controls for detailed editing or broader process structure viewing.

#### Enterprise Edition Additional Features

**Design System** — Figma design system with design tokens mapped directly to React codebase for brand alignment.

**ELK Layout** — Automatic diagram organization with multi-handle routing and label alignment.

**Smart Edge Routing** — Orthogonal, right-angled connections avoiding node collisions for maximum readability.

**Edge Reshaping** — Interactive handles adjusting orthogonal paths while preserving logic and supporting node rotation.

**Undo/Redo** — Instant reversal or reapplication of changes with customizable action tracking.

**Copy/Paste** — Duplication of nodes and workflow fragments preserving connections and configuration.

**Flow Runner** — Graph traversal executing node functions with async support, step-by-step execution, branching logic, and inter-node data propagation.

---

# FAQ
Source: https://www.workflowbuilder.io/faq

## Mostly Asked by Developers

**What is Workflow Builder?**
Workflow Builder is a frontend SDK for building visual workflow editors inside your own product. It lets you embed a drag-and-drop workflow designer into your SaaS while keeping execution, pricing, and business logic fully in your backend.

**Is Workflow Builder a product or an SDK?**
Workflow Builder is a white-label SDK, not a standalone SaaS product. You receive source code that becomes part of your application and can be customized to your domain.

**Can Workflow Builder be used as a foundation for building a new product or standalone app?**
Yes. Workflow Builder can serve as a production-ready foundation when building a new product or standalone application where workflows are a core part of the user experience. Teams use it to avoid reinventing workflow UI from scratch, while still owning execution logic, domain rules, data models, and overall product architecture from day one.

**Does Workflow Builder execute workflows?**
Workflow Builder is not a full workflow orchestration engine. Execution typically happens in your own backend. However, the Enterprise edition includes a Flow Runner plugin that can traverse the workflow graph and execute node functions directly in the editor. This allows teams to preview and test workflow logic before connecting it to their production backend.

**How is Workflow Builder different from n8n, Make, or Zapier?**
n8n, Make, and Zapier are SaaS platforms with hosted execution for running workflows as a service. Workflow Builder is an SDK designed for teams that need an embedded workflow editor to build their own automation or AI-powered products.

**Who is Workflow Builder for?**
Workflow Builder is for:
- SaaS companies embedding workflows into their products
- AI and automation products building agent designers, pipelines, or decision flows
- Engineering teams that already own (or plan to build) workflow execution on their backend

It is not for end users looking for a ready automation tool.

**Can non-technical users build workflows?**
Yes — within boundaries you define. Business users visually connect predefined steps, while developers control available nodes, rules, and validations.

**Why not build this ourselves?**
Most teams can build a basic editor, but UX edge cases, performance optimization, state management, and advanced features like multi-user collaboration quickly become complex. These challenges typically take 2–3x longer than expected to solve in a production-ready way. Workflow Builder provides a proven, scalable foundation so your team can focus on business logic instead of rebuilding workflow UX from scratch.

**How fast can we ship this to production?**
Most teams integrate Workflow Builder in weeks, not months, depending on customization and backend readiness. Some customers have had a fully live workflow editor running within 24 hours of purchase.

**What do we get when we buy Enterprise Edition license?**
You receive:
- Full frontend source code
- Configurable node library
- Schema-driven properties panel
- Plugin architecture
- Design system and theming
- Advanced features
- Support and warranty period
- Commercial usage rights

## Developer Implementation Questions

**What does Workflow Builder provide?**
Workflow Builder provides:
- Visual workflow canvas
- Node & edge modeling
- Schema-driven configuration UI
- Serialization to JSON
- Flow runner

It does not provide back-end execution or orchestration.

**What do we need to develop ourselves?**
You build:
- Execution engine
- Scheduling and retries
- Billing and limits
- Permissions logic
- AI calls and integrations

**How are workflows represented?**
Workflows are represented as JSON containing nodes, connections, metadata, and configuration values.

**Can workflows be created programmatically?**
Yes. Because workflows are JSON, you can generate, modify, and version them programmatically via your APIs.

**How do we add custom nodes?**
Custom nodes are implemented as React components and configured via JSON schema. You control behavior, forms, validation, and data mapping.

**How customizable is the UI?**
It's a fully white-label SDK, so you can adjust colors, typography, layout, dark/light mode, node visuals, and panels & controls. Once embedded, it can look and feel like your branded product.

**How do we prevent users from breaking production workflows?**
Common patterns include:
- Draft vs production environments
- Workflow locking
- Role-based permissions
- Backend validation before execution

**Can Workflow Builder support AI agents?**
Yes. Teams use Workflow Builder to design agent pipelines, prompt chains, decision trees, and tool-calling flows.

## Pricing and Licensing

**Is Workflow Builder licensed for commercial use?**
Workflow Builder is available under two licensing models:
- Community Edition — open source under the Apache 2.0 license, which allows commercial use
- Enterprise Edition — a commercial license that includes additional features, long-term support, and access to consulting services

Both editions can be used in commercial products.

**Can we resell Workflow Builder as part of our SaaS?**
Yes. You may embed and resell Workflow Builder as part of your product.

**Do we own the source code?**
Yes. You receive the frontend source code. You can modify it, extend it, and maintain it as part of your product.

**Is Workflow Builder open source?**
Workflow Builder is available in two editions:
- Community Edition — open source, licensed under Apache 2.0
- Enterprise Edition — commercial, proprietary version designed for teams that need advanced features, scalability, and long-term support

**Is pricing subscription-based or one-time?**
The Enterprise Edition of Workflow Builder is typically licensed as a one-time fee. The Community Edition is free of charge and available under the Apache 2.0 license.

**Are there any usage limits?**
No built-in limits. You control usage, execution frequency, billing, and limits in your backend.

**Is there revenue sharing?**
No. There is no revenue sharing — monetization is fully controlled by you.

**Can we start small and expand later?**
Yes. Many teams start with a limited node set and expand functionality over time.

## Consulting and Implementation

**Do you offer implementation or consulting services?**
Yes. While Workflow Builder can be integrated by your own team, many companies choose to work with the Workflow Builder team during the design and implementation phase. Building workflow interfaces involves many UX and architecture decisions. The Workflow Builder team has over a decade of experience designing diagram-based and workflow products and can help you avoid pitfalls early.

**Is consulting required to use Workflow Builder?**
No. Most teams integrate Workflow Builder independently using the provided source code and documentation. Consulting is optional and typically used to accelerate delivery or reduce risk.

**Can we start on our own and involve you later?**
Yes. This is the most common approach. Many teams begin with self-integration and involve the team later for specific challenges or refinements.

**Do you build execution engines or backend logic?**
Yes. Consulting can cover end-to-end implementation, including execution engines and backend workflow logic, orchestration, integrations, and production-ready backend architectures tailored to your product.

**Will consulting lock us into long-term services?**
No. Consulting is engagement-based and optional. There is no requirement for ongoing services or retainers.

**Who typically uses consulting support?**
Teams usually request support when:
- Frontend capacity is limited
- Workflows are core to the product UX
- Timelines are aggressive
- Advanced customization is required

**Is consulting available for both Community and Enterprise users?**
Yes. However, Enterprise customers typically use consulting more frequently due to production scale and commercial requirements.

**How is consulting priced?**
Consulting is scoped individually based on your needs and timeline. There is no fixed package — you only pay for the support you actually need.

---

# Compare: Workflow Builder vs n8n
Source: https://www.workflowbuilder.io/compare/n8n

## n8n Alternative: Open-Source Workflow Editor You Can Embed

n8n is a powerful automation platform. But when your product needs a custom, embeddable workflow editor SDK — not an off-the-shelf automation tool — the equation changes. Workflow Builder is the open source alternative to n8n for teams building products, not connecting services.

### The Core Difference

**n8n — Automation Platform.** Full-stack system with 500+ pre-built integrations, server-side execution engine, scheduling, credential management, and its own user interface. You use n8n's product.

**Workflow Builder — Embeddable Editor SDK.** React SDK with workflow semantics, smart edge routing, and a flow execution engine. You embed WB inside your product. Output = JSON to your backend.

The moment you need to own the UX, embed the editor in your SaaS product, or build custom node types specific to your domain, you hit the boundary where n8n stops being helpful and Workflow Builder starts.

For teams evaluating n8n alternatives, the key question isn't feature count — it's whether you need a platform or a component.

### Where n8n Falls Short

**Price: $50K+/year for embedding.** n8n's community edition is free for internal use, but the moment you want to embed it into your own product, you're looking at the n8n Embed license — approximately $50,000 per year. This is a recurring cost that scales with your business. Workflow Builder, by contrast, is a one-time license at €6,990 with an Apache 2.0 community tier. No recurring fees. No per-seat charges. No server infrastructure costs.

Client feedback: "The n8n pricing was horrible. And it's a very big tool — I needed to very quickly build something which is directly for my use case. Workflow Builder let me do exactly that."

**Bloated for custom use cases.** n8n ships with 500+ integration nodes, a server-side runtime, credential management, scheduling, webhooks, and a full administration interface. If your project needs a custom workflow editor with domain-specific nodes, then 90% of n8n is overhead you can't easily remove.

A widely-discussed Reddit thread titled "Why I Left n8n for Python" summarizes the key pain points: file handling struggles with processing, moving, or transforming large or multiple files; large workflows slow down or fail unpredictably; complex logic and error handling become painful to debug; missing functionality forces awkward, constrained workarounds.

**Customization hits a ceiling.** After a full day of hands-on research with n8n, our team's assessment was direct: the customization of n8n is limited.

What you get with n8n: n8n's canvas, n8n's node cards, n8n's property panels, n8n's sidebar. Custom nodes require self-hosting. The UX is n8n's — not yours.

What you get with WB: Your canvas, your node cards, your property panels, your sidebar. JSON Schema-driven custom nodes. Design tokens + CSS for full white-label control.

**Open source — but not for embedding.** n8n markets itself as open source. But the open-source promise doesn't extend to the embed use case. n8n uses a Sustainable Use License — source-available for internal use, but embedding in your product requires the proprietary Embed license at roughly $50K/year. Workflow Builder uses Apache 2.0 — permissive open-source license with no restrictions on embedding, modification, or commercial use. Free to embed in your product.

### Feature Comparison

| Feature | n8n | Workflow Builder |
|---------|-----|------------------|
| Pricing model | ~$50K/year embed license | €6,990 one-time |
| Open-source license | Sustainable Use License (embed = paid) | Apache 2.0 (community) |
| UX ownership | n8n's UX, limited theming | Full control — your brand, your design system |
| Custom node types | Requires self-hosting + n8n SDK | JSON Schema-driven, no React knowledge needed |
| Self-hosted option | Yes, full server stack required | Frontend-only (no server to host) |
| Framework support | Iframe embed only | React, Angular, Vue, vanilla JS via web component |
| Infrastructure | Full server stack required | Frontend-only, zero backend required |
| Pre-built integrations | 500+ connectors | None (you build what you need) |
| Execution engine | Full server-side execution | Built-in Flow Runner (frontend, portable to Node.js) |
| AI / LLM node support | 80+ built-in AI nodes | Custom AI Agent node type |
| Auto-layout | Basic | ELK algorithm built-in |
| Edge routing | Basic | Production-grade collision-avoiding |
| Undo / Redo | Limited | Built-in, production-ready |
| Time to production | Faster if using as-is; slower if customizing | 1–4 weeks (embed + customize) |
| Expert support | Community + enterprise tiers | 15+ years, 200+ projects |

### Pricing: One-Time vs. Recurring

The cost difference over three years is dramatic. n8n's embed license accumulates; Workflow Builder's doesn't.

**n8n embed — ~$50K per year.** Recurring license. Proprietary embed license. n8n's UI (limited customization). Server infrastructure required. Enterprise support available. 3-year cost: ~$150,000.

**Workflow Builder — €6,990 one-time.** Perpetual license. Full source code access. Apache 2.0 community tier. No per-seat or per-deploy fees. Figma Kit + dedicated support. 3-year cost: €6,990.

### The Right Tool for the Right Job

**Choose n8n when** you need a ready-made automation platform with hundreds of pre-built connectors. Your primary goal is connecting existing services without writing code. You don't need to embed the editor as a white-labeled component in your own product.

**Choose Workflow Builder when** you're building a SaaS product that needs an embedded, branded workflow editor. Your use case demands custom node types specific to your domain. You want one-time pricing without ongoing platform fees. You need to move fast with something tailored, not general-purpose.

### The Bottom Line

n8n embed 3 years: ~$150,000 + server infrastructure + limited UX customization.
Workflow Builder once: €6,990 + source code yours forever + full UX ownership.

If you're looking for an open-source n8n alternative to embed in your product — not another automation platform — Workflow Builder is the focused, developer-first answer. Backed by 15 years of diagramming expertise and 200+ commercial projects for companies like Siemens, BMW, and Canon.

The question isn't whether n8n is good. It's whether it's right — for your use case, your budget, and your product vision.

### FAQ — Workflow Builder vs n8n

**Is Workflow Builder a real open-source alternative to n8n?**
Yes. WB's Community Edition is Apache 2.0 — genuinely open source with no restrictions on embedding. Unlike n8n, which requires a ~$50K/year embed license for white-label use, WB's community tier is free to embed.

**Can I self-host Workflow Builder like n8n?**
WB is a frontend React SDK — there's nothing to "host". You embed it directly in your React app. No server infrastructure, no Docker containers, no database required.

**Is there a self-hosted alternative to n8n for embedding in my product?**
Yes. Workflow Builder is a self-hosted React SDK that runs as part of your existing frontend stack — it integrates directly into your product's architecture, wherever you already deploy it. Unlike n8n's self-hosted option, which introduces a separate server-side runtime (Node.js process, PostgreSQL, Redis, queue workers) that you need to operate alongside your product, WB adds no new infrastructure. It becomes part of your app. Workflow definitions stay as JSON within your own system — nothing leaves your environment. For teams in regulated industries (insurance, finance, healthcare) that need self-hosted deployment without adding a second platform to maintain next to their product, WB gives you a visual workflow editor that lives inside your existing stack, with full control over UX, branding, and data flow.

**How does pricing compare between Workflow Builder and n8n?**
WB Enterprise: €6,990 one-time, perpetual license, source code. n8n embed: ~$50K/year. WB has no recurring fees, no per-seat charges.

**How does Workflow Builder compare to n8n Enterprise for product teams?**
n8n Enterprise is designed for internal automation at scale — it adds SSO, role-based access, and audit logging on top of n8n's automation platform. The embed license starts at approximately $50,000 per year and renews annually. Workflow Builder Enterprise takes a fundamentally different approach: it's a one-time €6,990 license for a React SDK you embed directly into your own product. You get full source code, multi-tenant architecture support, white-label design tokens, and dedicated engineering support from a team with 15+ years and 200+ commercial diagramming projects. The key distinction: n8n Enterprise helps you automate internal processes, while WB Enterprise helps you ship a workflow editor as a feature of your product — at a fraction of the cost, with no recurring fees and no per-seat pricing.

**Does Workflow Builder have pre-built integrations like n8n?**
No — and that's by design. WB is a UI layer. You define your own node types and connect them to your backend. If you need 500+ connectors, n8n is the better choice.

**Can I build AI agent workflows with Workflow Builder?**
Yes. WB includes an AI Agent node type and has been used by teams like Plura AI and Athena Intelligence to build visual AI pipeline editors.

**What makes Workflow Builder different from other n8n alternatives?**
Most n8n alternatives (Activepieces, Make, Zapier) are automation platforms. WB is fundamentally different — it's an embeddable React SDK. You own the UX, branding, and execution logic.

**How long does it take to integrate Workflow Builder?**
1–4 weeks for a production-ready embedded workflow editor. n8n can be set up faster as-is, but customizing its UI for embedding takes significantly longer.

---

# Documentation Overview
Source: https://www.workflowbuilder.io/docs/overview

## What Is Workflow Builder?

Workflow Builder is a React SDK that gives you a production-ready workflow editor on day one. Embed drag-and-drop workflow UIs into your product. Open-source Community Edition available.

Workflow Builder is a React SDK for building and embedding visual workflow editors into your application. It is available in open-source and enterprise editions.

It provides a ready-made workflow editor UI, including canvas, nodes, edges, layout, forms, and configuration panels, so you don't have to build workflow UX from scratch.

Workflow Builder focuses exclusively on the frontend editor layer. Execution, orchestration, and business logic remain fully under your control.

### Key Features

- Visual workflow canvas with drag-and-drop interactions
- Node library with triggers, actions, conditions, branching, and delays
- Dynamic properties panel driven by JSON Schema
- Auto-save to local storage or external API
- Read-only mode for viewing without edit permissions
- Flow Runner for graph traversal and step-by-step execution
- Zoom in / out for navigating workflows at any scale
- Auto-layout for automatic node and edge positioning
- Smart edge routing that avoids collision with nodes
- Edge reshaping for fine-tuning connection paths on the canvas

### Scope

Workflow Builder focuses exclusively on the frontend editor layer. The SDK outputs workflow definitions as JSON that your own backend consumes and executes. For in-editor execution, the optional Flow Runner plugin (Enterprise) can traverse the workflow graph and run node functions directly.

### Typical Use Cases

Workflow Builder is commonly used to:
- Embed workflow editors into B2B SaaS products
- Build visual rule engines and configuration tools
- Design AI agent and automation workflow platforms
- Serve as a foundation for workflow-driven products and standalone apps

---

# AI Agent Workflows

> Source: https://www.workflowbuilder.io/ai-agent-workflows

## Embed a visual workflow builder for code-first AI agents

Your team estimated 4 months to build an AI agent canvas in your product. Workflow Builder ships most of it — visual editor, reference back-end, and a swappable Temporal integration for your durable execution layer of choice.

### The problem AI product teams talk about today

- A reliability infrastructure layer hit $300M Series D, then pivoted to "AI agents."
- Q1 2026: production AI teams shifted the conversation from "which model" to "how reliable."
- The missing piece is a visual layer that lets non-developers configure durable workflows.

### What you would have to build

An AI workflow surface has three layers. Workflow Builder ships two.

**Layer 1: Visual AI workflow editor**
- Canvas with libavoid edge routing and ELK auto-layout
- Schema-driven properties panels
- Plugin system with a factory-function contract
- JSON serialization for stable saves
- Real-time execution highlighting via SSE

**Layer 2: Reference back-end**
- Hono HTTP routes on `/api/workflows` and `/api/executions`
- Topological graph runner with parallel waves and decision pruning
- Public engine contract (three port interfaces)
- Structured event log and graph-level run history

**Layer 3: Engine integration**
- Temporal integration shipped as a reference adapter
- Per-activity retry profiles, V8 sandbox, deterministic replay
- Architecture ready for additional engine integrations

Building a comparable visual AI workflow editor from scratch (Layer 1 only) takes 700+ engineering hours and 300+ design hours.

### How code-first works in practice

- **Define a node type in JSON Schema.** Example "ai_agent" node: model (enum: gpt-4o, claude-sonnet-4-6, gemini-2.5-pro), systemPrompt, temperature (0–2, default 0.2), tools array.
- **The engine port — the contract.** Three TypeScript interfaces: WorkflowEnginePort, ActivityRunnerPort, EventEmitterPort.

### Two adoption paths

**Path A: Visual editor only** — Embed the React front-end in your product; your existing back-end and runner execute the JSON. Fastest path if execution already shipped.

**Path B: Visual editor + reference back-end + engine integration** — Adopt the full Workflow Builder SDK. The reference back-end provides the API surface and structured event log; the Temporal integration acts as a reference adapter. Engine-agnostic by design, ready for additional integrations.

### Honest comparison: Workflow Builder vs Alternatives

| Capability | Workflow Builder | LangGraph | Temporal | n8n | Custom Build |
|---|---|---|---|---|---|
| Embeddable in React product | Yes | No | No | Partial | Yes |
| Visual editor for engineers & non-engineers | Yes | No | No | Yes | Only if built |
| Code-first authoring | Yes | Yes | Yes | Limited | Yes by definition |
| Execution engine choice | Open contract; Temporal shipped | N/A | Temporal only | n8n only | Your choice |
| Durable execution out of box | Yes | No | Yes | Partial | No |

License: Apache 2.0 open source; Enterprise Edition available.

### Who this is for

- **Product owners:** ship an in-product AI workflow editor in days, not quarters; templates as the iteration unit; plugin patterns enable in-product workflow review; the canvas doubles as a debugging surface.
- **Lead devs:** factory-function plugin contract; public API surface (no deep imports); public engine contract for test adapters; live SSE execution stream.
- **CTOs:** source code in your repo; engine integration story (Temporal shipped, architecture ready for more); structured event log feeds audit and compliance pipelines; known operational footprint.

### When to choose Workflow Builder

**Choose Workflow Builder when:**
- You ship a workflow/AI feature inside a B2B SaaS, with the editor under your brand and auth
- Users mix developers and non-developers reading the same workflow
- You want code-first authoring with a visual canvas for review/debugging
- You want durable execution as the default with engine-choice freedom
- You care about owning source code and avoiding subscription lock-in
- You work in a regulated industry wanting a clear audit footprint

**Pick something else when:**
- You need a SaaS app for end users to sign up directly (use n8n, Make, Zapier)
- Workflows are pure code with no graph structure (use Temporal, Trigger.dev, Inngest)
- You're building a generic agent framework (use LangGraph or CrewAI)
- You need a single LLM call, not a workflow (use the LLM provider SDK)

### Architecture: four layers

- **Layer 01 — Your B2B SaaS product:** auth & identity stay in your platform; in-product UI shell with your routes/nav/brand; @workflow-builder/sdk React components.
- **Layer 02 — Reference back-end (WB ships):** Hono HTTP routes; pure-domain graph runner; public engine contract.
- **Layer 03 — Engine adapter (swappable bridge):** Temporal integration shipped today; custom engine adapter ready through the same contract.
- **Layer 04 — Execution engine, activities, your data:** durable engine runtime; LLM providers + retrieval; internal tools & APIs; observability & audit.

### Customer case studies

- **Athena Intelligence:** data and AI orchestration platform; users design multi-stage agent pipelines connected to a Neo4j knowledge graph; in production within the first sprint.
- **Plura AI:** automation platform for AI-native workflows; shipped a production-ready editor in weeks, not quarters, while keeping white-label control and its own execution layer.
- **Vercom:** featured customer.

### Track record

- 15 years building workflow and visual configuration tools
- 200+ workflow tools shipped to production
- 20+ enterprise customers
- Built by Synergy Codes; available for implementation partnership.

### Regulatory context

Annex III of the EU AI Act takes effect February 2027 for fintech, HR, edtech, and healthcare; the reference back-end records every workflow event in a structured log.

### FAQ

**Q: What is a code-first AI workflow platform?**
A code-first AI workflow platform lets engineers define workflows in code (typed SDKs, schema files, plugin functions) and renders the result as a runnable graph.

**Q: What execution engines does Workflow Builder support?**
Engine-agnostic by architecture; the Temporal integration ships today as a reference adapter, with architecture ready for additional integrations through the same public engine contract.

**Q: Can I embed an AI workflow editor inside my own SaaS product?**
Yes; the React front-end is published as the @workflow-builder/sdk npm package and takes hours, not weeks, to embed.

**Q: How do I build durable AI workflows that survive crashes and retries?**
Run on a durable execution engine; Workflow Builder is engine-agnostic and currently ships a Temporal integration with deterministic replay, sandboxed runs, and per-activity retry profiles.

**Q: How does Workflow Builder pair with LangGraph?**
Workflow Builder is the visual authoring layer; LangGraph is the runtime layer. They solve different problems.

**Q: What is agentic AI workflow automation?**
The practice of letting LLM agents drive a multi-step process with tool calls, decision branches, and feedback loops; it differs from classic automation due to non-determinism, expensive retries, and required human approval.

**Q: How does Workflow Builder compare to n8n, Make, or Zapier?**
n8n, Make, and Zapier are SaaS automation platforms aimed at end users; Workflow Builder is an SDK aimed at product teams embedding a workflow surface inside their own product.

**Q: What does the EU AI Act require for AI workflow audit trails?**
Annex III of the EU AI Act takes effect February 2027 for fintech, HR, edtech, and healthcare; Workflow Builder's reference back-end records every workflow event in a structured log.

**Q: What is the difference between the SDK, the reference back-end, and the Temporal integration?**
The SDK is the whole offering: three composable blocks. The visual editor is the React front-end; the reference back-end is the engine-agnostic execution shell; the Temporal integration is the adapter wiring the back-end to Temporal.

---

# Build vs Buy

> Source: https://www.workflowbuilder.io/build-vs-buy

## Build vs buy a workflow editor — the real cost of React Flow from scratch

React Flow gives you a canvas. Production workflow editors need 14–25 weeks of engineering on top — edge routing, auto-layout, node configuration, validation. Workflow Builder SDK fills that gap in 1–4 weeks. Here's the math, the trade-offs, and the teams who skipped the build.

### The decision you're actually making

Someone wants a visual workflow editor with drag-and-drop nodes. Most teams frame it as building on React Flow (MIT-licensed, free) versus paying a vendor (~$50K/year with limited UX control). That framing misses a third path: building on a workflow SDK — a production layer on top of React Flow that ships the 14–25 weeks of engineering you'd otherwise build from scratch — getting you to production in 1–4 weeks while preserving full UX control and source-code ownership. The real choice is: build from primitives, buy a SaaS platform, or buy an SDK and customize.

### Three paths compared

| Factor | Build from React Flow | Buy SaaS (n8n embed) | Buy SDK (Workflow Builder) |
|---|---|---|---|
| Upfront cost | $67,200–$120,000 dev time | ~$50,000/year license | €6,990 one-time license |
| Time to production | 14–25 weeks | Days to weeks | 1–4 weeks integration |
| Recurring cost | 1 FTE/year maintenance | ~$50,000/year + scaling | Minimal — own the code |
| UX & design control | Full (you build it) | Limited — vendor styling | Full — design tokens, scoped CSS |
| Source code ownership | Yes | No | Yes — Apache 2.0 (Community) or commercial license |
| Vendor lock-in risk | None | High — pricing, deprecation, embed terms | None — perpetual license, no subscription |
| Edge routing, auto-layout, node config | Build from scratch | Vendor-defined | Included (libavoid, ELK, JSON Schema) |
| Custom node types | Full freedom | Vendor-constrained | Full freedom |
| Best for | Internal prototypes; teams with existing canvas infra | Standalone automation product where workflow IS the product | SaaS embedding a workflow editor as a feature |

### What 14–25 weeks of "build from scratch" actually looks like

React Flow provides the canvas with pan-zoom, node rendering, and drag-to-connect. Everything else is on you:

| Feature | Build effort | Cost (at $120/hr) |
|---|---|---|
| Obstacle-avoiding edge routing | 2–4 weeks | $9,600–$19,200 |
| Auto-layout (ELK integration) | 1–2 weeks | $4,800–$9,600 |
| Schema-driven node configuration panels | 2–4 weeks | $9,600–$19,200 |
| Design system integration | 1–3 weeks | $4,800–$14,400 |
| Performance optimization (500+ nodes) | 2–4 weeks + ongoing | $9,600–$19,200 |
| Execution state visualization | 2–4 weeks | $9,600–$19,200 |
| Validation & error states | 2–3 weeks | $9,600–$14,400 |
| **Total initial build** | **14–25 weeks** | **$67,200–$120,000** |
| Maintenance, year one | 1 FTE equivalent | $150,000+ |

- **Opportunity cost:** a senior React developer spending four months on a workflow canvas can't spend it on the core product.
- **Compounding maintenance:** this isn't static infrastructure — it evolves with React updates, new node types, mobile gestures, and accessibility audits.

### When to build, when to buy a platform, when to buy an SDK

**Build from React Flow when:**
- The editor IS your product (not a feature) with years of engineering maintenance capacity
- It's an internal prototype or narrow tool with no production polish required
- Your team has shipped a production workflow canvas before, with a reusable abstraction layer
- You need a custom interaction model an SDK would constrain

**Buy a SaaS platform (n8n embed, Zapier-style) when:**
- Standardized automation flows are sufficient
- Users are technical and tolerate vendor UI
- ~$50K/year recurring is acceptable
- You're OK with vendor lock-in on the visual layer, branding, and roadmap

**Buy an SDK and customize (Workflow Builder) when:**
- You're embedding a workflow editor as a feature inside an existing B2B SaaS product
- A deadline matters — investor demo, roadmap commitment, market window
- Design system integration is non-negotiable
- You want source code, no recurring license, no vendor lock-in
- Your team is strong at React/business logic but lacks specialized canvas engineering

### Workflow Builder is built on React Flow

Workflow Builder is a production workflow editor layer built on top of React Flow — not a replacement. Three-layer stack:
1. Your product (application, users, brand)
2. Workflow Builder SDK (edge routing, auto-layout, schema-driven UI, design system, flow runner)
3. React Flow / @xyflow/react (canvas, nodes, edges, pan/zoom, drag-to-connect)

### Case study: Athena Intelligence — one day to a production editor

- Industry: AI for legal & renewable-energy data intelligence
- Constraint: investor demo deadline; no internal canvas engineering capacity
- Result: deployed a production-grade workflow editor in 1 day using a white-label license; full customization (form logic, CSS, design tokens) in 1 week; weeks of internal development eliminated.

### Case study: Vercom / MessageFlow — RCS Flow Studio built fast

- Industry: CPaaS — enterprise messaging
- Constraint: enterprise clients required a no-code RCS campaign builder with advanced features
- Result: shipped RCS Flow Studio — an enterprise visual campaign builder — using Workflow Builder's React SDK with custom RCS nodes and token-based theming. Delivered ahead of schedule and budget, ahead of Vercom's own backend integration; highest internal quality score; positioned as the most user-friendly RCS tool on the market.
- Quote: "I found you guys, I was like, wait a minute. Someone's actually focused on the front end part. That's where expertise is tough."

### Company background

Built on React Flow · 15+ years of diagramming projects · 200+ commercial workflow editors delivered. Shortlisted for Technology of the Year 2026 by money.pl. Companies referenced: Siemens, BMW Group, Canon.

### FAQ

**Q: Should we build a workflow editor or buy one?**
Build from React Flow only if the editor IS your product (not a feature) with capacity for 14–25 weeks plus ongoing maintenance. For B2B SaaS adding a workflow editor as a feature, buying an SDK (Workflow Builder) typically wins on time-to-market (1–4 weeks vs 14–25), cost ($6,990 one-time vs $67,200–$120,000), and maintenance burden. Buying a SaaS platform (n8n-style) makes sense only when vendor UX and ~$50K/year recurring are both acceptable.

**Q: How much does it cost to build a workflow editor on React Flow?**
A production-grade editor takes 14–25 weeks of senior developer time — $67,200 to $120,000 at $120/hr — plus roughly one full-time engineer per year for maintenance. Under-estimated categories: obstacle-avoiding edge routing (2–4 weeks), schema-driven node configuration (2–4 weeks), design system integration (1–3 weeks), performance optimization beyond 500 nodes.

**Q: What does React Flow not include?**
React Flow provides canvas primitives — pan-zoom, node rendering, drag-to-connect, basic edges. It intentionally leaves the production layer to developers: obstacle-avoiding edge routing, automatic layout, schema-driven node configuration panels, design system integration, validation logic, execution state visualization, and performance optimization for hundreds of nodes.

**Q: Is Workflow Builder a replacement for React Flow?**
No — Workflow Builder is built on React Flow. It adds the production layer (edge routing, auto-layout, node config, design tokens) without replacing React Flow's canvas primitives, so you keep access to React Flow's documentation, ecosystem, and plugin community.

**Q: What's the difference between Workflow Builder and n8n?**
n8n is a standalone workflow automation platform with its own UI and execution engine — you embed n8n's product into yours, accepting vendor styling and ~$50K/year licensing. Workflow Builder is an SDK — you embed the editor component into your product, fully styled with your design system, with your backend executing workflows. n8n is right when the workflow IS the product; Workflow Builder is right when the workflow is a feature.

**Q: How long does Workflow Builder integration take?**
1–4 weeks for most teams. Athena Intelligence had a working demo in 1 day and full customization in 1 week. Vercom shipped a production RCS campaign builder ahead of their backend timeline. Scope depends on custom node types and design system integration depth.

**Q: Can we migrate from a React Flow build to Workflow Builder later?**
Yes — since Workflow Builder is built on React Flow, existing node components, edge logic, and React Flow state typically port without rewriting. Migration replaces in-house edge routing, auto-layout, and configuration panels with Workflow Builder equivalents, then maps design tokens.

---

# Compare: Workflow Builder vs ActivePieces

> Source: https://www.workflowbuilder.io/compare/activepieces

## ActivePieces alternative: React SDK for embed in your SaaS

### The Core Difference

ActivePieces is an open-source Zapier alternative — a complete iPaaS product, a great choice for internal automation and cost-sensitive ops. Workflow Builder is a different shape: a headless React SDK that mounts an editor canvas inside your product, not an iframe next to it. ActivePieces embeds via iframe; Workflow Builder is a React component you mount inside your product's render tree.

### Where ActivePieces Falls Short

- Editor still renders on ActivePieces infrastructure, inside an iframe, not as a React component in the same render tree.
- Built on React 18 + XYFlow, but the React code is internal to the ActivePieces app, not a packaged SDK you can import.
- To customize the canvas you must fork the repo and maintain a custom build, or use iframe wrapping.
- White-label resale or multi-tenant customer deployment requires a separate Embed license from ActivePieces with a custom contract.

### Feature Comparison

| Feature | ActivePieces | Workflow Builder |
|---------|--------------|------------------|
| Target audience | Ops teams, SMB, Zapier replacement seekers | Product engineering teams embedding a canvas in their SaaS |
| Primary embed surface | Iframe of ActivePieces UI / white-label hosted instance | React component (canvas inside your UI) |
| Editor as React SDK | No — canvas internal to the AP app, embed = iframe | Yes. Native React component, theme-aware |
| Frontend framework | React 18 + Vite + XYFlow (React Flow) + Tailwind + shadcn + Zustand + TanStack Query | React + TypeScript |
| Open-source license | MIT on the core; Embed license needed for white-label resale | Apache 2.0, no restrictions |
| White-label and resale | In-house allowed; resale requires Embed license contract | Allowed by license |
| Self-hosted option | Yes — MIT, Docker / Kubernetes / Helm / one-click | Yes — Apache 2.0, your infra |
| UX ownership | AP UI inside iframe; canvas extension requires forking the app | You own canvas, nodes, theme, routing |
| Custom node types | TypeScript Pieces SDK, CLI scaffold | TypeScript node API, full form schema control |
| Generic workflow shapes | iPaaS shape — trigger + action chains | First-class — data, approval, back-office, domain nodes |
| AI and agent support | Yes — AI Agent builder with full piece catalog (~280+) plus MCP servers as tools | Yes, runtime-agnostic (LangGraph, Temporal, custom) |
| Pre-built integrations | 280+ pre-built pieces + separate MCP server catalog | Pattern library + reference nodes; bring your own |
| Runtime and execution engine | ActivePieces engine baked in (TypeScript backend) | Bring your own (Temporal adapter ships in reference backend) |
| Time to first integration | ~1-2 hours for non-coder flow on hosted AP; embedding = iframe of the AP app | ~1 day for white-label embed (Athena Intelligence case) |
| Backend stack | TypeScript (Node.js) | Your choice — Node, Go, Python, .NET, any |
| Pricing — cloud entry | Free / $25 Plus / $150 Business / Enterprise custom | n/a (SDK, not hosted product) |
| Pricing — perpetual license | Enterprise Embed license is recurring | EUR 6,990 one-time Enterprise |

### Pricing

- ActivePieces cloud: Free (1,000 tasks/month, 2 active flows, 200 AI credits), Plus $25/month, Business $150/month, Enterprise custom. Self-host Community free under MIT (unlimited tasks). Enterprise Embed license: paid, recurring, custom contract. 3-year cost example (Business tier): $150 × 36 = $5,400 for one workspace.
- Workflow Builder: Apache 2.0 (no restrictions on white-label or resale); self-host free. Enterprise license EUR 6,990 one-time, includes reference backend with Temporal adapter. 3-year cost: EUR 6,990 total, no recurring fee.

### The Bottom Line

ActivePieces is a strong product if you need a Zapier replacement and 280+ pre-built pieces out of the box. Workflow Builder is a different shape — a published React component, not an iframe-wrapped app. ActivePieces if internal automation is the use case; Workflow Builder if a customer-facing embed in a React product is the use case.

### FAQ

**Q: What is ActivePieces?** An open-source Zapier alternative — a complete iPaaS product with a visual flow editor, 280+ pre-built pieces (plus a separate MCP server catalog), and a TypeScript Pieces SDK. MIT-licensed on the core.

**Q: Is ActivePieces open source?** Yes — the core is MIT-licensed. In-house use is free. White-label resale or multi-tenant customer deployment requires a separate Embed license with a custom contract. Workflow Builder is Apache 2.0 with no equivalent contract step.

**Q: Can I embed ActivePieces inside my SaaS product?** Yes, via iframe of the AP UI or a white-label hosted instance. You cannot mount the editor canvas as a React component in your render tree.

**Q: Does ActivePieces have more pre-built connectors?** Yes — AP ships 280+ pre-built pieces (plus a separate MCP server catalog), a massive head start for trigger-action automation.

**Q: How long does integration take?** Athena Intelligence shipped a white-label integration in 1 day of engineering; total elapsed time from first call to integrated editor was 3 days.

**Q: What does Workflow Builder cost?** EUR 6,990 one-time for the Enterprise license. No per-workspace, per-seat, or per-execution fee on the editor side.

---

# Compare: Workflow Builder vs Dify

> Source: https://www.workflowbuilder.io/compare/dify

## Dify alternative: embeddable workflow editor with React SDK

### The Core Difference

Dify is a complete LLMOps platform with a visual studio — the right tool when you run an internal LLM application. Workflow Builder is a headless React SDK that mounts an editor canvas inside your product. The one-line choice: pick Dify when you run an internal LLM application; pick Workflow Builder when the editor is the product.

### Where Dify Falls Short

- Dify's license explicitly prohibits operating Dify as a multi-tenant SaaS service without a commercial license.
- The license also forbids removing the Dify logo and copyright notice from the console.
- Embed is chat widget / iframe only — the editor canvas is part of the Dify product, not a packaged SDK.
- AI-only focus: purpose-built for LLM applications. If your product also needs classic data, approval, or back-office flows, Dify is the wrong abstraction.

### Feature Comparison

| Feature | Dify | Workflow Builder |
|---------|------|------------------|
| Target audience | Operators running internal LLM applications and LLMOps | Product engineering teams embedding a canvas in their SaaS |
| Primary embed surface | Chat widget, iframe of Dify app, REST API | React component (canvas inside your UI) |
| Editor as React SDK | No — React frontend exists but is not packaged as an SDK | Yes. Native React component, theme-aware |
| Open-source license | Apache 2.0 with two restrictions | Apache 2.0, no restrictions |
| Multi-tenant SaaS resale | Forbidden without commercial license | Allowed by license |
| Self-hosted option | Yes — Community Edition free; Premium / Enterprise licensed | Yes. Apache 2.0, your infra |
| UX ownership | Dify owns the console UI; you own iframes and chat embeds | You own canvas, nodes, theme, routing |
| Custom node types | Plugin marketplace + custom nodes within Dify console | TypeScript node API, full form schema control |
| Generic workflow (non-AI) | Scoped to AI-app flows | First-class. Data, approval, back-office, domain nodes |
| AI and agent support | Native — 30+ model providers, 50+ tools, RAG, agents | Yes, runtime-agnostic (LangGraph, Temporal, custom) |
| LLMOps (datasets, monitoring, prompt versioning) | Built in — core of the Dify value proposition | Bring your own — WB is the editor |
| Runtime and execution engine | Python Flask / Celery baked in | Bring your own (Temporal adapter ships in reference backend) |
| Time to first integration | ~30 minutes for a RAG chatbot; canvas embed in your product not supported | ~1 day for white-label embed (Athena Intelligence case) |
| Frontend branding control | Dify logo and copyright must remain in console | Full — no required logos or attribution |
| Pricing — cloud entry | Sandbox free, Professional $59/mo, Team $159/mo, Enterprise custom | n/a (SDK, not hosted product) |
| Pricing — perpetual license | Enterprise Edition self-host is licensed and recurring | EUR 6,990 one-time Enterprise |

### Pricing

- Dify cloud: Sandbox free, Professional $59/mo, Team $159/mo, Enterprise custom. Self-host: Community Edition free under "Apache 2.0 + two restrictions"; Premium/Enterprise self-host licensed and recurring. 3-year cost (Team tier): $159 × 36 = $5,724 for one workspace. License: Apache 2.0 with two restrictions (multi-tenant SaaS + branding).
- Workflow Builder: Apache 2.0, no restrictions; self-host free, white-label allowed. Enterprise license EUR 6,990 one-time (reference backend included). 3-year cost: EUR 6,990, no recurring license fee.

### The Bottom Line

Dify is a strong product if you are running an internal LLM application and want LLMOps in one place. Workflow Builder is a different shape: the editor, packaged as a React SDK, with a license that does not constrain what you do downstream. Dify if the chatbot is the product, Workflow Builder if the editor is the product.

### FAQ

**Q: What is Dify?** An open-source LLMOps platform with a visual workflow studio, RAG pipelines, prompt management, datasets, observability, and a plugin marketplace. Licensed under Apache 2.0 with two restrictions: no multi-tenant SaaS, no removing the Dify logo.

**Q: Can I run Dify as part of a multi-tenant SaaS product?** Not without a commercial license. The Dify Open Source License explicitly forbids operating Dify as a multi-tenant SaaS service — the most common B2B SaaS shape.

**Q: How does Workflow Builder differ from Dify?** WB is a React SDK that mounts the editor canvas inside your product; Dify is a standalone platform with chat-widget and iframe embed. WB is a single-purpose editor; Dify is a full LLMOps stack. WB's Apache 2.0 has no multi-tenant SaaS or branding restrictions.

**Q: Does Workflow Builder support AI agents and LLM nodes?** Yes. WB is runtime-agnostic, so you can plug in LangGraph, Temporal, OpenAI, Anthropic, or a custom backend.

**Q: Do I need to know Python to use Workflow Builder?** No. WB is TypeScript-first with a React SDK and connects to any backend that consumes the JSON graph definition.

**Q: What does Workflow Builder cost?** EUR 6,990 one-time for the Enterprise license. No per-workspace, per-seat, or per-execution fee on the editor side.

---

# Compare: Workflow Builder vs Flowise

> Source: https://www.workflowbuilder.io/compare/flowise

## Flowise alternative: embeddable workflow editor with React SDK

### The Core Difference

Flowise is a standalone visual studio for LangChain.js. Workflow Builder is a headless React SDK that lives inside your product. The choice: pick Flowise when the chatbot is the product; pick Workflow Builder when the editor is the product.

### Where Flowise Falls Short

- Flowise exposes chatbots (chat widget embed), not the editor canvas for customers to build flows.
- LangChain.js lock-in: depends on LangChain.js migration cycles; v1.0 (October 2025) created breaking changes.
- Non-AI workflows don't fit — Flowise models only LLM chains; data, approval, and back-office flows lack proper node types.
- Open-core with enterprise paywall: SSO, RBAC, and audit logs require a separate Commercial License beyond the Apache 2.0 Community Edition.

### Feature Comparison

| Feature | Flowise | Workflow Builder |
|---------|---------|------------------|
| Target audience | AI builders deploying chatbots and agent flows | Product engineering teams embedding a canvas in their SaaS |
| Primary embed surface | Chat widget (fullchatbot and bubble variant) and REST API | React component (canvas inside your UI) |
| Editor as React SDK | No. React frontend exists but is not packaged as an SDK | Yes. Native React component, theme-aware |
| Open-source license | Open-core: Community Edition Apache 2.0; enterprise/ directory under separate Commercial License | Apache 2.0, no separate enterprise tier |
| White-label and resale | Community Edition allows white-label and resale; enterprise features require paid license | Allowed without restrictions |
| Self-hosted option | Yes. Community Edition free under Apache 2.0; paid Enterprise license for SSO, RBAC | Yes. Apache 2.0, your infra |
| UX ownership | Editor UI is Flowise-branded; canvas is not extensible | You own canvas, nodes, theme, routing |
| Custom node types | TypeScript node SDK, well-structured component model | TypeScript node API, full form schema control |
| Generic workflow (non-AI) | Scoped to LLM and agent flows | First-class. Data, approval, back-office, domain nodes |
| AI and agent support | Yes, native to LangChain.js | Yes, runtime-agnostic (LangGraph, Temporal, custom) |
| Pre-built LLM nodes | Large pre-built library on LangChain.js | Pattern library + reference nodes; bring your own |
| Runtime and execution engine | LangChain.js runtime baked in | Bring your own (Temporal adapter ships in reference backend) |
| Time to first integration | ~1-2 hours for chatbot widget; canvas embed not supported | ~1 day for white-label embed (Athena Intelligence case) |
| Backend stack | Node.js + LangChain.js | Your choice. Node, Go, Python, .NET, any |
| Pricing — cloud entry | $35/mo Starter, $65/mo Pro, custom Enterprise | n/a (SDK, not hosted product) |
| Pricing — perpetual license | Enterprise license is recurring | EUR 6,990 one-time Enterprise |

### Pricing

- Flowise: Free tier (2 flows, 100 predictions/month, 5 MB storage), Starter $35/month, Pro $65/month, Enterprise custom (SSO, RBAC, audit logs, air-gapped). Community Edition Apache 2.0 (white-label and resale allowed); Enterprise self-host paid, recurring. 3-year cost (Pro): $2,340 for one workspace.
- Workflow Builder: Apache 2.0, no separate enterprise tier; self-hosted free, white-label allowed. Enterprise license EUR 6,990 one-time. 3-year cost: EUR 6,990, no recurring fees.

### The Bottom Line

Flowise is a strong product if your shipping surface is a chatbot and your runtime is LangChain.js. Workflow Builder is a different shape — the editor is yours, the canvas is yours, the runtime is yours. Flowise if the chatbot is the product, Workflow Builder if the editor is the product.

### FAQ

**Q: What is Flowise?** A standalone visual studio for building LangChain.js flows, with an open-core license model: the Community Edition is Apache 2.0; the enterprise/ directory ships under a separate Commercial License.

**Q: How does Workflow Builder differ from Flowise?** (1) WB is a React SDK mounting the editor canvas inside your product; Flowise is standalone. (2) WB is runtime-agnostic; Flowise bakes in LangChain.js. (3) WB is single-license Apache 2.0; Flowise is open-core.

**Q: Can I embed Flowise inside my SaaS product?** You can embed the chat widget. You cannot embed the editor canvas as a React component. Workflow Builder is the canvas, packaged as a React SDK.

**Q: What does Workflow Builder cost?** EUR 6,990 one-time for the Enterprise license. No per-workspace, per-seat, or per-execution fee.

---

# Compare: Workflow Builder vs Langflow

> Source: https://www.workflowbuilder.io/compare/langflow

## Langflow alternative: embeddable workflow editor with React SDK

### The Core Difference

Langflow is a Python visual studio for LangChain pipelines (MIT-licensed, now in the IBM watsonx portfolio). Workflow Builder is a TypeScript-first React SDK that mounts inside your SaaS with no parent platform. The choice: pick Langflow when the studio is the workspace; pick Workflow Builder when the editor is the product.

### Where Langflow Falls Short

- Not an SDK: the React frontend is open source but not packaged as an SDK. If your product needs an editor inside your UI, you fork the langflow-ai/langflow repo — that is not embedding.
- Python lock-in: the runtime assumes Python; Workflow Builder is runtime-agnostic.
- IBM vendor direction: Langflow is now positioned inside the IBM watsonx portfolio; the hosted DataStax product was retired 9 April 2026.
- AI-scoped only: Langflow is LangChain-first. If your customers also build classic data or approval flows, Langflow is the wrong abstraction.

### Feature Comparison

| Feature | Langflow | Workflow Builder |
|---------|----------|------------------|
| Target audience | Data-science teams prototyping LangChain pipelines | Product engineering teams embedding canvas in SaaS |
| Primary embed surface | Standalone studio + OpenAPI HTTP endpoint export | React component (canvas inside your UI) |
| Editor as React SDK | No. React frontend is open source but not packaged as an SDK | Yes. Native React component, theme-aware |
| Open-source license | MIT | Apache 2.0 |
| Vendor coupling | DataStax (2024) → IBM watsonx portfolio (IBM acquired DataStax in 2025) | None |
| Self-hosted option | Yes. MIT, Docker / Kubernetes | Yes. Apache 2.0, your infra |
| UX ownership | Editor UI is Langflow-branded; canvas is not extensible | You own canvas, nodes, theme, routing |
| Custom node types | Python-first custom components | TypeScript node API, full form schema control |
| Generic workflow (non-AI) | Scoped to LangChain LLM and agent flows | First-class. Data, approval, back-office, domain nodes |
| AI and agent support | Native LangChain bundle + 100+ pre-built components; MCP servers | Yes, runtime-agnostic via ports (Temporal adapter ships; LangGraph, custom = bring-your-own) |
| Pre-built LLM nodes | 100+ pre-built LangChain components | Pattern library + reference nodes; bring your own |
| Runtime and execution engine | Python + FastAPI runtime; LangChain as a first-class bundle | Bring your own (Temporal adapter ships in reference backend) |
| Time to first integration | Fast for prototype on Langflow; canvas embed in your product = fork | ~1 day for white-label embed (Athena Intelligence case) |
| Backend stack | Python + LangChain | Your choice. Node, Go, Python, .NET, any |
| Pricing — cloud entry | Enterprise via IBM watsonx (hosted DataStax Langflow on Astra DB retired 9 April 2026); OSS self-host free | n/a (SDK, not hosted product) |
| Pricing — perpetual license | Enterprise via IBM watsonx is recurring | EUR 6,990 one-time Enterprise |

### Pricing

- Langflow: MIT (OSS core). Cloud: Enterprise via IBM watsonx (no list price published; DataStax hosted Astra DB retired April 9, 2026). Self-host free. Hobby prototype: ~$30–$100 per month.
- Workflow Builder: Apache 2.0. Enterprise EUR 6,990 one-time (includes reference backend with Temporal adapter). Self-host free. 3-year cost: EUR 6,990, no recurring fee.

### The Bottom Line

Langflow is a strong product if your team is Python and the studio is the workspace; for that shape you can be in production this week. Workflow Builder is a different shape: the editor is yours, the runtime is yours, the vendor relationship is yours — which you give up in Langflow the moment your enterprise tier moves to IBM watsonx.

### FAQ

**Q: What is Langflow?** A standalone Python visual studio for building pipelines, with LangChain as a first-class bundle. Production deployment today is either IBM watsonx Orchestrate (enterprise) or self-host on Docker / Kubernetes (OSS). The OSS core is MIT-licensed.

**Q: What changes for Langflow under IBM ownership?** DataStax acquired Langflow in 2024; IBM acquired DataStax in 2025. The OSS core remains MIT. The enterprise direction tilts toward the IBM watsonx portfolio. The hosted DataStax Langflow product on Astra DB was retired on 9 April 2026.

**Q: How does Workflow Builder differ from Langflow?** WB is a React SDK that mounts the editor canvas inside your product; Langflow is a standalone studio. WB is TypeScript-first and runtime-agnostic; Langflow is Python and LangChain-coupled. WB has no parent platform.

**Q: Do I need to know LangChain to use Workflow Builder?** No. WB has no runtime dependency. You can connect it to LangGraph, LangChain Python, a custom Node service, a Go backend, or anything that consumes the JSON graph definition.

**Q: What does Workflow Builder cost?** EUR 6,990 one-time for the Enterprise license, including the React SDK and reference backend with Temporal adapter. No per-workspace, per-seat, or per-execution fee on the editor side.

---

# Open Source
Source: https://www.workflowbuilder.io/open-source

## Open Source Workflow Builder — Apache 2.0 React SDK + Reference Backend

Workflow Builder is open source under the Apache 2.0 license. Apache 2.0 covers the visual workflow editor (the React SDK), the reference back-end, and the Temporal adapter. You can use it commercially, embed it in a closed-source product, and ship it inside a paid SaaS — with no copyleft and no obligation to open your own code.

### License footprint

The Community Edition is Apache 2.0. That means: commercial use is allowed; there is no copyleft (you do not have to open-source your product); there is no relicensing trap — no BSL (Business Source License) and no SSPL (Server Side Public License). This is a hard commit: the Community Edition stays Apache 2.0. We are not planning to move the open-source core to a restrictive license later.

### Why Apache 2.0 (and not BSL or SSPL)

Many "open-source" workflow and automation tools ship under source-available licenses (BSL, SSPL) or a Sustainable Use License that blocks embedding in a commercial product without a separate paid Embed license. Apache 2.0 has none of those restrictions: it is a true permissive open-source license, OSI-approved, with an explicit patent grant. You keep full UX ownership and can white-label and resell the editor as part of your SaaS.

### GitHub presence

The source code (monorepo, pnpm workspaces), issues, and contribution guidelines live at https://github.com/synergycodes/workflowbuilder. Built on React Flow (@xyflow/react) with TypeScript and JSON Schema-driven properties.

### FAQ

**Q: Is Workflow Builder really open source?** Yes. The Community Edition is licensed under Apache 2.0, an OSI-approved permissive license.

**Q: Can I use Workflow Builder commercially?** Yes. Apache 2.0 permits commercial use, including embedding in a closed-source or paid product.

**Q: Does the license require me to open-source my product?** No. Apache 2.0 is not copyleft. Your product code stays yours.

**Q: Will the open-source edition move to BSL or SSPL later?** No. Keeping the Community Edition on Apache 2.0 is a hard commit.

**Q: What is the difference between Community and Enterprise?** Community (Apache 2.0, free) is the editor SDK. Enterprise (EUR 6,990 one-time) adds ELK auto-layout, smart edge routing, edge reshaping, undo/redo, copy/paste, Flow Runner, the Figma design system, and priority support. Source code included, perpetual license.

---

# Reference Stack
Source: https://www.workflowbuilder.io/reference-stack

## Open Source Workflow Orchestration Reference Architecture — Engine-Agnostic, Apache 2.0

Workflow Builder ships an open-source reference architecture for workflow orchestration: three apps behind three port interfaces, one Apache 2.0 reference implementation you can clone today. It is reference code, not a runtime — you own and run it on your infrastructure.

### Three apps, three ports

The reference stack is structured around three port interfaces so responsibilities stay decoupled:

- **WorkflowEnginePort** — how workflow definitions are executed by an engine.
- **ActivityRunnerPort** — how individual node activities/tasks are run.
- **EventEmitterPort** — how execution events are emitted back to the editor/UI (for live visualization, audit logs, etc.).

Because the engine sits behind WorkflowEnginePort, you can swap the execution engine without rewriting the editor. Temporal ships as the reference adapter for durable execution; Inngest, Camunda, AWS Step Functions, and in-house engines are all swappable behind the same port.

### What you get (and what you build)

You get the editor (React SDK), the reference back-end wiring, and the Temporal adapter — the parts that are expensive to design and easy to get wrong. You keep control of the engine choice, scheduling, persistence, permissions, and billing. "We ship reference code, not runtime."

### FAQ

**Q: What is the reference stack?** An open-source (Apache 2.0) reference architecture showing how the visual editor, a back-end, and an execution engine fit together across three port interfaces.

**Q: Can I change the execution engine?** Yes. The engine sits behind WorkflowEnginePort. Temporal is the shipped reference; Inngest, Camunda, Step Functions, or a custom engine can be swapped in without touching the editor.

**Q: Do I have to use Temporal?** No. Temporal is the reference adapter for durable execution, not a requirement.

**Q: Is the reference stack production-ready as-is?** It is reference code you clone and adapt — a proven starting architecture, not a hosted runtime you point traffic at.

---

# Temporal Integration
Source: https://www.workflowbuilder.io/integrations/temporal

## Visual Editor for Temporal Workflows — React SDK

Add a visual canvas on top of your Temporal workflows. Workflow Builder is a React SDK for end-user authoring, human-in-the-loop (HITL) signals, and customer-facing workflow builders. Mount it in your product in about 1 day.

### The pairing problem

Temporal gives you durable, reliable execution — retries, timeouts, crash recovery, replay. What it does not give you is a UI your end users can use to author or watch workflows. Teams end up either exposing raw Temporal to customers (they can't) or hand-building an editor (weeks of work). Workflow Builder is the authoring/visualization layer that pairs with Temporal's execution layer.

### Architecture

Your product mounts the Workflow Builder React component. The editor emits a JSON workflow definition. Your back-end translates that JSON into a Temporal workflow (activities, signals, timers) and runs it durably. Execution events flow back to the canvas (via the EventEmitterPort pattern in the reference stack) for live visualization and audit. HITL approval steps map naturally to Temporal signals.

### Quick start

1. Install the Workflow Builder React SDK and mount the editor in your app.
2. Map the editor's JSON node/edge output to your Temporal workflow + activity definitions.
3. Wire execution events back to the canvas for live status and audit logging.

### FAQ

**Q: Does Workflow Builder replace Temporal?** No. Temporal executes; Workflow Builder is the visual authoring and visualization layer on top.

**Q: How do human-in-the-loop steps work?** Approval/HITL nodes in the editor map to Temporal signals that pause and resume the workflow.

**Q: How long does integration take?** Teams typically mount a working editor in about 1 day, then map nodes to their Temporal definitions.

**Q: Is the Temporal adapter open source?** Yes — it ships in the Apache 2.0 reference back-end.

---

# LangGraph Integration
Source: https://www.workflowbuilder.io/integrations/langgraph

## Visual Editor for LangGraph Agents — React SDK

Add a visual canvas to your code-first LangGraph agents. Workflow Builder is a React SDK for end-user authoring, HITL approval flows, and multi-agent UI. Mount it in your product in about 1 day.

### The pairing problem

LangGraph is a code-first framework for building stateful, multi-agent applications in Python. It is excellent for engineers, but your end users cannot read or edit Python graphs. Workflow Builder gives them a visual canvas to author and inspect agent flows, while your LangGraph code stays the source of execution truth.

### Purely additive

The integration is additive: you do not rewrite your agent logic. Your product mounts the Workflow Builder React component; the editor produces a JSON graph; your back-end translates that JSON into LangGraph nodes and edges. The canonical pairing pattern keeps authoring in the UI and execution in LangGraph.

### Architecture

Editor (React SDK) → JSON graph definition → your back-end maps JSON to LangGraph nodes/edges → LangGraph runs the agents. HITL approval flows and multi-agent hand-offs are modeled as nodes in the editor and enforced in your LangGraph runtime. Execution/state can stream back to the canvas for visibility.

### Quick start

1. Mount the Workflow Builder React editor in your product.
2. Translate the editor's JSON node/edge output into LangGraph nodes and edges in your back-end.
3. Surface run state / approvals back on the canvas for end users.

### FAQ

**Q: Do I have to rewrite my LangGraph agents?** No. The integration is additive — your LangGraph code remains the execution layer; Workflow Builder adds the authoring/visualization UI.

**Q: Who is this for?** AI product teams whose end users need to author, inspect, or approve agent workflows without touching Python.

**Q: How do approvals work?** HITL approval nodes in the editor map to gates enforced in your LangGraph runtime.

**Q: Is Workflow Builder coupled to LangChain or Python?** No. Workflow Builder is TypeScript-first and runtime-agnostic; LangGraph is one supported target among several (Temporal ships as the reference adapter).

---

# Call Flow Builder (CPaaS / CCaaS)
Source: https://www.workflowbuilder.io/use-case/call-flow-builder

## Ship the call flow builder your customers are asking for

Workflow Builder is a visual editor SDK you embed in your CPaaS or CCaaS product: a React SDK for the editor plus a Temporal-based execution back-end. Use it to deliver a call flow builder instead of building one from scratch. Schema-first nodes, plugin system, design tokens, customizable without forking the source code. Today customers wire call flows across number lists, routing rules, RONA and overflow, each on its own form; Workflow Builder replaces that with one canvas, branded as yours.

### Where the problem shows up

- Estimating the build — "ship the visual editor" has been on the roadmap for two quarters and the more the work is sized, the bigger it gets.
- Three months in — the first 200 nodes worked, the first customer with 800 did not; subflows, custom virtualization and focus mode are already over budget.
- Live and watching tickets stack — some flows are slow to load, some cannot be edited, and the fix is bigger than the original build.

### What you get

Visual layer: CSS design tokens and cascade layers for rebranding without forking, composable UI (palette, properties panel, canvas assembled as you need), read-only viewer mode, undo/redo with 100-step history, system-clipboard cut/paste across tenants, EN and PL i18n.

Call flow modeling: schema-first nodes (IVR, business hours, holiday routing, voicemail defined as JSON Schemas that generate validated configuration panels — no React code for standard nodes), custom node and edge templates (a keypad with a port per DTMF key, decision nodes with badges on outgoing edges), connection validation via isValidConnection that rejects invalid links mid-drag, and a Variable Picker so one node reads another node's output.

Extensibility: a plugin system with named slots and function decorators so customizations survive upgrades, plus the `@workflowbuilder/sdk` npm package with public GitHub and TypeScript-first types.

### React Flow thresholds at call flow scale

| Nodes per flow | Works out of the box | What you build yourself |
| --- | --- | --- |
| up to ~200 | React Flow defaults | nothing |
| 200–1,000 | memoization, debouncing | custom virtualization tuning, stable nodeTypes refs |
| 1,000–5,000 | subflows + lazy loading | Web Workers for layout, focus mode, custom minimap |
| 5,000–10,000 | subflows are mandatory | custom virtualization, level-of-detail rendering |
| 10,000+ | — | hybrid canvas + React Flow architecture |

Two bottlenecks decide everything: rendering (each node is DOM, each edge an SVG path — browsers handle 200 elements fine, struggle at 1,000, give up at 10,000) and auto-layout (ELK and dagre scale trees to hundreds of thousands, but flow graphs like call flows top out at a few thousand). It is the shape of the data, not the framework.

### Four scenarios

- CPaaS provider, API-first: one giant routing graph across 50 deployments becomes one shared template flow plus 50 small variant subflows — 80% of routing logic is shared, only VIP rules, holiday calendars and time-of-day branching vary. Onboarding drops from days to hours.
- CCaaS challenger scaling to mid-market: flows averaging 4,000 nodes break down to ~200 nodes of routing logic and ~3,800 nodes of repeated data (holiday calendars, number lists, opening hours) that does not belong in the graph. Same UI, 20x performance.
- Voice AI platform: AI agent flows are loop-heavy and intent-driven, IVR is tree-heavy and rule-driven — one layout for both breaks both. One editor, two graph modes.
- Enterprise voice, compliance-driven: the audit log is structurally a layer on top of any configuration change, not a per-node feature. One central layer covers TCPA, GDPR and ePrivacy reporting.

### Choose Workflow Builder when / pick something else when

Choose it when you are embedding visual call flow configuration in a CPaaS or CCaaS product, flows sit in the 500–5,000 node range per customer, your end users are admins or installation teams, your stack is React, and you want source-code ownership instead of a per-seat subscription. Pick something else when you need a SaaS app your end customers sign up for directly (n8n, Make, Zapier), when you are committed to one giant unified graph without analyzing whether it pulls apart into subflows (GoJS may serve better), or when adding a React layer is not feasible.

### FAQ

**Q: What is a call flow builder?** A visual editor that lets non-technical admins configure how inbound and outbound voice calls route through a system, without writing code. It plugs into the underlying voice infrastructure (PBX, SIP, WebRTC) that actually runs the calls.

**Q: How do you embed a call flow builder in a CPaaS or CCaaS product?** Three layers: (1) the editor frontend embedded in your product UI, (2) an execution back-end on Temporal that runs the flows, (3) your product's own layer — branding, business logic, voice integration, permissions, audit. Workflow Builder ships layers 1 and 2; you own layer 3.

**Q: Can you build a production-grade call flow editor in React Flow alone?** Technically yes — React Flow's own FAQ says no special optimization is needed up to ~500 nodes. Past that you build the performance work, layout patterns and domain node library yourself.

**Q: What is the difference between an IVR designer and a call flow builder?** An IVR designer is a subset focused on the voice-menu tree a caller navigates. A call flow builder is the full graph: IVR menus, routing logic, RONA/overflow handling, integration triggers and time-based branching.

**Q: How does it pair with Twilio, Vonage or Bandwidth?** Workflow Builder is provider-agnostic — the back-end has no voice code of its own. You write the voice adapter (Twilio, Vonage, Bandwidth, Plivo, Telnyx, Sinch, Infobip or your own SIP infrastructure) that plugs into node executors.

**Q: What is included in the back-end?** Flow execution on Temporal, real-time monitoring over SSE, an event-sourced execution log, snapshot immutability, per-node error routing (fail / continue / errorRoute) and cancellation — with production seams (default allow-all auth ready for your IdP, multi-tenant identity, rate limiting) rather than production promises. You add voice adapters, business permissions, the audit layer and custom node executors.

**Q: What if a call flow goes beyond 5,000 nodes?** It exists and has been solved in client work, but it does not ship out of the box: sometimes hybrid canvas rendering, sometimes moving data out of the graph, sometimes rethinking whether it needs to be one graph at all.

---

# Marketing Automation Workflows (Martech)
Source: https://www.workflowbuilder.io/use-case/marketing-automation-workflows

## Enrich your martech product with a visual workflow editor

Marketers and customer-ops teams want a canvas, not a stack of forms. Workflow Builder is the React SDK you embed to give them one — on your stack, under your brand, on the engine you already run. Your engineers define the building blocks; your marketing users design campaigns and customer journeys visually. It pairs the editor with an open-source (Apache 2.0) reference back-end and an engine-agnostic runtime with a Temporal adapter included.

### Five product types

- CPaaS / messaging: rich cards, carousels, suggested replies, conditions, delays and channel-fallback routing (SMS to WhatsApp to Voice to Email) as drag-and-drop nodes. Node types you define once; the canvas serializes each flow to JSON your back-end maps to your engine.
- Customer journey: triggers, waits, branches, exits and A/B splits as visual nodes that fire from your events and evaluate against your segments — the marketer's diagram is the executable graph, so no separate spec drifts out of sync.
- Marketing automation: sends, tags, waits and splits as action nodes, each with a configuration form generated from your schema, so marketers get guided, validated inputs instead of another settings screen.
- Subscription / monetization: offers, paywalls, audience rules and A/B tests as a canvas the growth team owns, branching on trial status, plan tier, platform or app version.
- CDP / data activation: segment, condition, channel and action as typed nodes running self-hosted inside your infrastructure, so data and consent never leave your stack.

### Why it matters

Whether a journey lives in code or in a grid of config forms, the marketing and customer-ops teams who run the campaigns cannot see or shape it themselves. Your execution engine has a dashboard, but it was built for your team to debug, not for a marketer to read. And when every tweak — a new branch, a different delay, another A/B split — is an engineering ticket, your customers move at your release cadence instead of their own.

### Build vs buy

Embedding Workflow Builder gives you a complete editor layer inside your product, white-label, with source-code ownership, your own engine kept in place, and a one-time payment. Building from scratch means months of engineering before your marketing users ship a single campaign. Stitching it onto React Flow yourself leaves the other 80% — schema-driven config panels, undo/redo, copy/paste, validation, theming — for you to build and keep working. Buying a SaaS platform (for example n8n embed) means inheriting its engine and look, a recurring license, lock-in on pricing and embed terms, and source code that is never yours.

### How it fits your product

1. The editor lives in your product — style it, arrange the layout (canvas, palette, properties panel, topbar), and model your own business objects and rules on it.
2. It connects to your back-end — the open-source reference back-end gets you running faster, or connect your own.
3. Your engine runs the flows — Workflow Builder is the canvas, not the runtime. Whatever powers your sends, journeys or campaigns keeps doing it; nothing to rip out.

### Customer proof

Vercom's MessageFlow needed a visual campaign builder its enterprise clients could use to design complex RCS customer journeys without developer dependency. Building it in-house would have been a multi-quarter project; they embedded Workflow Builder and shipped RCS Flow Studio ahead of schedule and within budget, before their own back-end integration was done.

### FAQ

**Q: How is it different from a marketing automation platform like HubSpot or Braze?** A marketing automation platform is a product you use; Workflow Builder is a layer you embed in the product you sell. Your customers get the visual builder inside your app, on your own engine.

**Q: How is it different from building on React Flow ourselves?** React Flow is the canvas library; Workflow Builder is built on top of it and adds the production layer — schema-driven configuration panels, flow serialization, validation, undo/redo, copy/paste, editable edges, auto-layout.

**Q: How is it different from an embedded iPaaS like n8n Embed?** n8n's value is its ready-made blocks and engine, which becomes limiting once you need your own objects, business rules and branding inside your product. In Workflow Builder a node is just a JSON Schema, and the open-source reference engine can be run or replaced with your own.

**Q: How does it connect to our existing engine or API?** It is engine-agnostic — the visual layer, not a new runtime. Keep your current campaign or messaging engine; the reference back-end coordinates the hand-off, or point the editor straight at your own API.

**Q: Can our customers build flows without writing code?** Yes. Your engineers define the available steps once; marketing and customer-ops users drag, connect and configure them visually.

**Q: What journey and campaign logic can our customers model?** Triggers, conditions, delays and decision branching are node types on the canvas, and you add your own with a JSON Schema per node in the Community Edition. For multi-channel and RCS products, rich cards, carousels, suggested replies and channel-fallback routing are modeled as nodes too.

**Q: Is it self-hosted — do our data and consent stay with us (GDPR / CCPA)?** Yes. It runs self-hosted inside your own infrastructure, so customer data, consent records and the customer relationship stay with you.

**Q: Is Workflow Builder open source or paid?** Two editions. Community (free, Apache 2.0): the visual editor, the open-source reference back-end, the Temporal adapter and the canvas core — undo/redo, copy/paste, schema-driven properties, read-only mode, JSON serialization. Enterprise (one-time perpetual license, €6,990): everything in Community plus the advanced canvas plugins (ELK auto-layout, smart edge routing, interactive edge reshaping, Flow Runner), a Figma Kit, priority support and source access to Enterprise-only components.

---