---
# === IDENTITY ===
id: business/erp-integration/boomi-atomsphere-vs-flow/2026
canonical_question: "What is the difference between Dell Boomi AtomSphere and Boomi Flow - when to use each?"
aliases:
  - "Boomi Integration vs Boomi Flow comparison"
  - "When to use Boomi AtomSphere vs Flow"
  - "Boomi iPaaS vs Boomi low-code workflow platform"
  - "Boomi data integration vs workflow automation"
entity_type: erp_integration
domain: business > erp-integration > boomi-atomsphere-vs-flow
region: global
jurisdiction: global
temporal_scope: 2024-2026

# === SYSTEM PROFILE ===
systems:
  - name: "Boomi Integration (AtomSphere)"
    vendor: "Boomi"
    version: "January 2026 Release"
    edition: "Professional, Pro Plus, Enterprise, Enterprise Plus, Pay-As-You-Go"
    deployment: "cloud"
    api_surface: "REST, SOAP, HTTP, FTP, JMS, Kafka, AMQP"
  - name: "Boomi Flow"
    vendor: "Boomi"
    version: "March 2026 Release"
    edition: "Included in Boomi Enterprise Platform"
    deployment: "cloud"
    api_surface: "REST (Service Connectors)"

# === VERIFICATION ===
last_verified: 2026-03-03
confidence: 0.85
version: 1.0
first_published: 2026-03-03

# === TEMPORAL VALIDITY ===
temporal_validity:
  status: volatile
  last_breaking_change: "January 2026 Release"
  next_review: 2026-08-30
  change_sensitivity: high

# === CONSTRAINTS ===
constraints:
  - "Boomi Integration and Boomi Flow are separate modules on the Boomi Enterprise Platform -- they are NOT interchangeable"
  - "Boomi Flow cannot perform data transformations (field mapping, data cleansing) -- delegate to Integration for ETL"
  - "Boomi Integration cannot render user-facing forms or approval UIs -- delegate to Flow for human-in-the-loop"
  - "Flow runs entirely on Boomi-hosted AWS infrastructure (regional VPCs) -- no self-hosted Flow runtime option exists"
  - "Integration's self-hosted Atom/Molecule runtimes have no equivalent in Flow -- Flow is always cloud-only"
  - "Using both together requires configuring an AtomSphere Service Connector in Flow to invoke Integration processes"

# === SKIP CONDITIONS ===
skip_this_unit_if:
  - condition: "User only needs Boomi Integration (AtomSphere) runtime limits and capabilities"
    use_instead: "business/erp-integration/boomi-atomsphere-capabilities/2026"
  - condition: "User needs MuleSoft Anypoint capabilities"
    use_instead: "business/erp-integration/mulesoft-anypoint-capabilities/2026"
  - condition: "User needs a general iPaaS vs low-code platform comparison (not Boomi-specific)"
    use_instead: "business/erp-integration/ipaas-comparison/2026"

# === AGENT HINTS ===
inputs_needed:
  - key: primary_need
    question: "What is your primary need?"
    type: choice
    options:
      - "data integration (connecting systems, ETL, API orchestration)"
      - "workflow automation (approvals, onboarding, human tasks)"
      - "both (data integration + human-in-the-loop workflows)"
  - key: user_involvement
    question: "Do end users interact with the process?"
    type: choice
    options:
      - "no -- fully automated, system-to-system"
      - "yes -- users need forms, approvals, or task assignments"
  - key: deployment_preference
    question: "Do you need on-premise deployment?"
    type: choice
    options:
      - "cloud-only is fine"
      - "must run on-premise (data residency, firewall constraints)"

# === DISTRIBUTION ===
canonical_source: "https://knowledgelib.io/business/erp-integration/boomi-atomsphere-vs-flow/2026"
suggested_citation: "Source: knowledgelib.io -- AI Knowledge Library (verified 2026-03-03)"

# === RELATED UNITS ===
related_kos:
  depends_on: []
  related_to:
    - id: "business/erp-integration/boomi-atomsphere-capabilities/2026"
      label: "Boomi AtomSphere platform capabilities, limits & pricing"
  solves: []
  alternative_to: []
  often_confused_with: []

# === SOURCES ===
sources:
  - id: src1
    title: "Boomi Enterprise Platform Overview"
    author: Boomi
    url: https://boomi.com/platform/
    type: official_docs
    published: 2026-01-15
    reliability: authoritative
  - id: src2
    title: "Boomi Flow: Low-Code Workflow Automation"
    author: Boomi
    url: https://boomi.com/platform/flow/
    type: official_docs
    published: 2026-01-15
    reliability: authoritative
  - id: src3
    title: "Flow Technical Architecture Overview"
    author: Boomi
    url: https://help.boomi.com/docs/Atomsphere/Flow/LegacyTopics/c-flo-Techref_Architecture_b7cbf7a7-bcd0-4d1c-b926-69854df699ec
    type: official_docs
    published: 2026-01-15
    reliability: authoritative
  - id: src4
    title: "Flow Overview - Boomi Documentation"
    author: Boomi
    url: https://help.boomi.com/docs/Atomsphere/Flow/Flow_overview
    type: official_docs
    published: 2026-01-15
    reliability: authoritative
  - id: src5
    title: "Integration Runtimes: Atoms, Molecules, and Atom Clouds"
    author: Boomi
    url: https://help.boomi.com/docs/Atomsphere/Integration/Getting%20started/int-Atoms_Molecules_and_Atom_Clouds_d8fe8ad8-3ba5-4eb1-967d-cd0fc9ffb062
    type: official_docs
    published: 2026-01-15
    reliability: authoritative
  - id: src6
    title: "Flow Identity Providers Overview"
    author: Boomi
    url: https://help.boomi.com/docs/Atomsphere/Flow/Topics/Setting_up_and_managing_flows/Identity_providers/flo-IDP_cc718062-51e1-4c35-b9e7-3e971ac28249
    type: official_docs
    published: 2026-01-15
    reliability: authoritative
  - id: src7
    title: "What is Boomi AtomSphere Platform? - TechTarget Definition"
    author: TechTarget
    url: https://www.techtarget.com/searchcloudcomputing/definition/Dell-Boomi
    type: technical_blog
    published: 2025-06-01
    reliability: moderate_high
  - id: src8
    title: "Boomi Pricing & Editions"
    author: Boomi
    url: https://boomi.com/pricing/
    type: official_docs
    published: 2026-01-15
    reliability: authoritative
---

# Boomi AtomSphere vs Boomi Flow: When to Use Each

## TL;DR

- **Bottom line**: AtomSphere (Boomi Integration) is for system-to-system data integration and API orchestration; Flow is for human-in-the-loop workflow automation with forms, approvals, and low-code apps. Use both together when a process needs data transformation AND user interaction. [src1]
- **Key limit**: Flow has no data transformation engine (no maps, no ETL) -- it delegates to Integration processes via the AtomSphere Service Connector. Integration has no user-facing UI -- it delegates to Flow for forms and approvals. [src2, src4]
- **Watch out for**: They share a platform name but are architecturally different products. Flow runs on AWS (regional VPCs, ECS containers). Integration runs on Atoms (Java runtimes, self-hosted or cloud). You cannot deploy Flow on-premise. [src3, src5]
- **Best for**: Flow is best for employee onboarding, approval workflows, field service apps, and customer portals. Integration is best for ERP/CRM sync, ETL pipelines, B2B/EDI, and API management. [src1, src2]
- **Authentication**: Integration uses HMAC token auth (Platform API) or OAuth 2.0/Basic/mTLS (deployed endpoints). Flow uses OAuth 2.0, OIDC, or SAML via external identity providers for end-user authentication. [src5, src6]

## System Profile

Boomi AtomSphere (now Boomi Integration) and Boomi Flow are two distinct modules within the Boomi Enterprise Platform. Despite sharing the Boomi brand, they have fundamentally different architectures, runtimes, and use cases. Integration handles data movement and transformation between systems. Flow handles workflow orchestration involving human participants. They can be used independently or together, with Flow invoking Integration processes via service connectors.

This card compares both products side by side to help architects and agents determine the correct module for a given requirement. It does NOT cover Boomi DataHub, B2B/EDI Management, Event Streams, or API Management as standalone modules.

| System | Role | Architecture | Runtime |
|---|---|---|---|
| Boomi Integration (AtomSphere) | Data integration, ETL, API orchestration | Java-based Atom runtime (self-hosted or Boomi Cloud) | Atoms, Molecules, Atom Clouds [src5] |
| Boomi Flow | Workflow automation, low-code apps, human-in-the-loop | Cloud-native on AWS (ECS containers, Aurora DB, regional VPCs) | Boomi-hosted only (no self-hosted option) [src3] |
| Combined | Data integration + human workflows | Flow calls Integration via AtomSphere Service Connector | Both runtimes active |

## API Surfaces & Capabilities

| Capability | Boomi Integration (AtomSphere) | Boomi Flow |
|---|---|---|
| **Primary purpose** | System-to-system data integration | Human-in-the-loop workflow automation [src2] |
| **Development model** | Visual process designer (Build tab) | Drag-and-drop flow canvas [src2] |
| **Runtime** | Atom (Java, single-node), Molecule (clustered), Atom Cloud (multi-tenant) | AWS ECS containers in regional VPCs [src3, src5] |
| **Self-hosted option** | Yes (Atom, Molecule, Private Atom Cloud) | No (cloud-only) [src3] |
| **Connectors** | 200+ application connectors + Connector SDK | Service connectors (invoke external APIs, including AtomSphere) [src1, src4] |
| **Data transformation** | Full: Maps, Groovy scripts, Data Process shapes | None: delegates to Integration [src4] |
| **User interface** | None (headless) | Low-code forms, pages, portals, swimlane views [src2] |
| **Human tasks** | None | Approvals, assignments, routing, notifications [src2] |
| **Execution model** | Event-driven, scheduled, real-time, batch | State machine (players advance through steps) [src4] |
| **State management** | Stateless per execution (no persistent state) | Stateful (flow state persisted across user sessions) [src4] |
| **Identity management** | Connection-level auth (OAuth, Basic, mTLS) | Identity provider integration (OAuth 2.0, OIDC, SAML) [src6] |
| **B2B/EDI** | Yes (Enterprise edition) | No [src1] |
| **Master Data Hub** | Yes (Enterprise edition) | No [src1] |
| **API Management** | Yes (publish, secure, monitor APIs) | No (but can expose Flow APIs via Integration) [src1] |
| **Pricing model** | Connector-based (per-system) + message throughput | Per-user or included in Enterprise Platform bundle [src8] |

## Rate Limits & Quotas

### Boomi Integration Limits

| Limit Type | Value | Applies To | Notes |
|---|---|---|---|
| Cloud listener document size | 1 MB | Web Services Server on Runtime Cloud | Self-hosted: unlimited [src5] |
| Low Latency execution timeout | 30 seconds | Cloud Execution Workers | Self-hosted: configurable |
| AtomSphere Platform API | 10 req/s | Management API calls | All editions |
| Connector Capacity Tier | 10M messages/connector/year | Enterprise | Overage triggers additional billing [src8] |

### Boomi Flow Limits

| Limit Type | Value | Applies To | Notes |
|---|---|---|---|
| Flow runtime hosting | AWS regional VPCs only | All Flow deployments | No self-hosted option [src3] |
| Concurrent flow executions | Platform-managed (elastic) | All tenants | Auto-scaled by Boomi [src3] |
| Flow API rate limiting | Service-dependent | Service connector calls | Each service connector has its own limits |
| Data storage | Amazon Aurora (managed) | Flow state data | Regional data residency within selected AWS region [src3] |

## Authentication

| Context | Integration | Flow |
|---|---|---|
| **Platform login** | Boomi Platform SSO (SAML/OIDC) | Same Boomi Platform SSO |
| **End-user auth** | N/A (headless) | OAuth 2.0, OIDC, SAML via external IdP [src6] |
| **API endpoint auth** | Basic, mTLS, OAuth 2.0 (CC, JWT), API Key | Flow-issued player URLs (restricted to authenticated users) |
| **System-to-system** | Connection component credentials (per connector) | Service connector credentials (token-based) |

### Authentication Gotchas

- Flow's identity provider delegation means end-user auth is only as strong as the configured IdP -- if you skip adding an IdP, flows are accessible to anyone with the URL. [src6]
- Integration connection credentials are stored per-environment. Rotating credentials requires updating each environment separately.
- When Flow calls Integration via the AtomSphere Service Connector, authentication uses the Boomi account's API credentials, not the end-user's identity. User context must be passed as data if needed.

## Constraints
<!-- Agents: read this section before recommending any integration approach from this unit.
     These are hard constraints that must not be violated. -->

- **Flow has NO data transformation engine**: It cannot map fields, cleanse data, or perform ETL. Any data transformation must be delegated to an Integration process via the AtomSphere Service Connector. [src4]
- **Integration has NO user-facing UI**: It cannot render forms, approval pages, or portals. Any human interaction must be delegated to Flow or an external application. [src1]
- **Flow is cloud-only**: There is no self-hosted Flow runtime. Organizations with strict on-premise data residency requirements cannot use Flow for workflows involving sensitive data that must not leave their network. [src3]
- **Flow regional data residency**: Flow data is stored in the selected AWS region (US, EU, AU, etc.). Cross-region flow execution is not supported -- you must select the region at tenant creation. [src3]
- **Combined usage requires connector configuration**: Using Flow + Integration together is not automatic. You must explicitly create an AtomSphere Service Connector in Flow and configure it to call specific Integration processes. [src4]
- **Licensing**: Flow is included in the Boomi Enterprise Platform bundle but may require per-user licensing for external-facing flows (customer portals, partner workflows). [src8]

## Integration Pattern Decision Tree

```
START -- When should I use AtomSphere vs Flow vs both?
+-- Does the process involve human interaction (forms, approvals, tasks)?
|   +-- NO (fully automated, system-to-system)
|   |   +-- Use Boomi Integration (AtomSphere) only
|   |   +-- Examples: ERP-to-CRM sync, ETL pipeline, B2B/EDI, API orchestration
|   +-- YES (humans need to review, approve, or input data)
|       +-- Does it ALSO need data transformation or multi-system integration?
|       |   +-- NO (simple workflow, no complex data movement)
|       |   |   +-- Use Boomi Flow only
|       |   |   +-- Examples: PTO approval, document review, simple surveys
|       |   +-- YES (workflow + data integration)
|       |       +-- Use both: Flow for UI/approvals + Integration for data processing
|       |       +-- Pattern: Flow form --> AtomSphere Service Connector --> Integration process --> target systems
|       |       +-- Examples: employee onboarding (Flow forms + Integration provisions accounts across HR/IT/Payroll)
+-- Does the process need on-premise execution?
|   +-- YES --> Boomi Integration only (Atom/Molecule on-premise); Flow cannot run on-premise
|   +-- NO --> Either or both, based on human interaction needs above
+-- What's the budget model?
    +-- Connector-based (per-system) --> Integration
    +-- Per-user (portal/app users) --> Flow
    +-- Enterprise Platform bundle --> Both included [src8]
```

## Quick Reference

### Capability Comparison

| Capability | Boomi Integration (AtomSphere) | Boomi Flow | Winner |
|---|---|---|---|
| **System-to-system integration** | 200+ connectors, full ETL, batch + real-time | Limited to service connectors (REST calls) | Integration |
| **Human-in-the-loop workflows** | None | Drag-and-drop, approvals, assignments, forms | Flow |
| **Data transformation** | Maps, Groovy scripting, Data Process shapes | None | Integration |
| **Low-code app development** | None | Form builder, page builder, portal builder | Flow |
| **On-premise deployment** | Yes (Atom, Molecule, Private Atom Cloud) | No (cloud-only) | Integration |
| **Cloud-native scaling** | Molecule clusters (manual scaling) | AWS ECS auto-scaling | Flow |
| **Identity management** | Connection-level | Full IdP integration (OAuth/OIDC/SAML) | Flow |
| **B2B/EDI** | Yes (Enterprise edition) | No | Integration |
| **API Management** | Yes (publish, throttle, monitor) | No | Integration |
| **Master Data Hub** | Yes (Enterprise edition) | No | Integration |
| **Event Streams** | Yes (Kafka-like) | No | Integration |
| **Process visibility** | Execution logs, process reporting | Swimlane views, player state tracking | Tie (different focus) |

### Use Case Matrix

| Use Case | Recommended Module | Why |
|---|---|---|
| ERP-to-CRM data sync | Integration | System-to-system, needs field mapping and transformation |
| Employee onboarding workflow | Flow + Integration | Flow handles forms/approvals; Integration provisions accounts |
| Order-to-cash automation | Flow + Integration | Flow handles approval steps; Integration moves data between ERP/WMS/CRM |
| B2B/EDI with trading partners | Integration | EDI requires specialized protocols (AS2, X12, EDIFACT) |
| Customer self-service portal | Flow | User-facing forms, identity management, workflow routing |
| ETL/data migration | Integration | Batch processing, data transformation, bulk connectors |
| Approval workflow (PTO, expenses) | Flow | Human tasks, routing, notifications, no data transformation needed |
| API gateway / management | Integration (API Management) | Publish, secure, throttle APIs |
| Field service management | Flow | Mobile-friendly forms, offline capability, task assignment |
| Master data synchronization | Integration (DataHub) | Golden record management, cross-system sync |
| Scheduled report generation | Integration | Scheduled execution, file generation, FTP delivery |
| Customer satisfaction surveys | Flow | Form builder, response collection, routing |

## Step-by-Step Integration Guide

### 1. Determine which module you need

Evaluate your requirements against the decision tree above. The key differentiator: does a human need to interact with the process? If yes, you need Flow (possibly with Integration). If no, you need Integration only. [src1, src2]

```
# Quick assessment checklist:
# [ ] Human forms or approvals needed?        --> YES = Flow
# [ ] Data transformation / field mapping?     --> YES = Integration
# [ ] On-premise runtime required?             --> YES = Integration only
# [ ] Both human interaction AND data mapping? --> YES = Flow + Integration
# [ ] Simple survey / task routing only?       --> YES = Flow only
```

**Verify**: If you answered YES to both human interaction AND data transformation, you need both modules connected via the AtomSphere Service Connector.

### 2. Set up Boomi Flow (if human workflows needed)

Create a new flow in the Flow canvas. Configure identity provider if end-users need authentication. [src2, src6]

```
# In Boomi Platform:
1. Navigate to Flow canvas
2. Create new flow (drag-and-drop canvas)
3. Add steps: Start --> Map Element (form) --> Decision --> Outcome
4. Configure identity provider:
   - Go to Tenant Settings > Identity Providers
   - Add OAuth 2.0, OIDC, or SAML provider
   - Test login flow with a test user
5. Publish and generate player URL
```

**Verify**: Open the player URL in a browser --> the flow should render the first form step. If an IdP is configured, it should redirect to login first.

### 3. Connect Flow to Integration (if combined usage)

Configure the AtomSphere Service Connector in Flow to invoke Integration processes. [src4]

```
# In Flow:
1. Go to Services > Create Service
2. Select "Boomi Integration" service type
3. Configure connection:
   - AtomSphere API URL: https://api.boomi.com
   - Account ID: YOUR_ACCOUNT_ID
   - Username: YOUR_INTEGRATION_USER
   - Password: YOUR_PASSWORD
4. Map Flow data types to Integration process input shapes
5. Add the service connector as a step in your flow canvas
6. When the flow reaches this step, it invokes the Integration process
   and waits for the response before proceeding to the next step
```

**Verify**: Run the flow --> when it reaches the Integration step, check Boomi Integration > Process Reporting for the corresponding execution.

### 4. Build the Integration process (for data operations)

Create the Integration process that Flow will invoke. Design it to accept input from Flow, perform data operations, and return results. [src5]

```
# In Integration Build tab:
1. Create new process
2. Start shape: Web Services Server (to receive Flow's call)
3. Add connector shapes for target systems (Salesforce, SAP, DB, etc.)
4. Add Map shapes for data transformation
5. Return response to Flow
6. Set execution mode:
   - Low Latency if < 30s processing (Flow expects fast response)
   - General if longer processing (use async pattern with callback)
7. Deploy to Atom/Molecule/Cloud
```

**Verify**: Test the Integration process independently with a test payload --> verify it returns the expected response shape. Then test end-to-end from Flow.

## Code Examples

### JSON: Flow service connector configuration

```json
// Input:  Boomi account credentials, Integration process details
// Output: Configured service connector for Flow-to-Integration communication

{
  "serviceName": "EmployeeOnboarding-Integration",
  "serviceType": "AtomSphere",
  "connection": {
    "atomSphereUrl": "https://api.boomi.com",
    "accountId": "YOUR_BOOMI_ACCOUNT_ID",
    "username": "integration-user@company.com",
    "authType": "basic"
  },
  "operations": [
    {
      "name": "ProvisionNewEmployee",
      "processId": "abc123-def456-ghi789",
      "atomId": "production-atom-001",
      "inputProfile": "EmployeeOnboardingInput",
      "outputProfile": "ProvisioningResult"
    }
  ]
}
```

### Python: Invoke a Flow programmatically via its API

```python
# Input:  Flow tenant ID, flow ID, player URL
# Output: Flow execution state and current step

import requests

FLOW_TENANT_ID = "your-tenant-id"
FLOW_ID = "your-flow-id"
FLOW_REGION = "https://flow.manywho.com"  # US region

# Initialize a new flow execution
init_url = f"{FLOW_REGION}/api/run/1/state"
headers = {
    "Content-Type": "application/json",
    "ManyWhoTenant": FLOW_TENANT_ID
}

payload = {
    "id": FLOW_ID,
    "inputs": [
        {
            "developerName": "EmployeeName",
            "contentValue": "Jane Smith",
            "contentType": "ContentString"
        }
    ]
}

response = requests.post(init_url, json=payload, headers=headers, timeout=30)

if response.status_code == 200:
    state = response.json()
    print(f"Flow state: {state.get('stateId')}")
    print(f"Current step: {state.get('currentMapElementDeveloperName')}")
else:
    print(f"Error {response.status_code}: {response.text}")
```

### cURL: Test Flow and Integration connectivity

```bash
# Input:  Boomi account credentials, Atom ID
# Output: Verify both Integration and Flow are operational

# 1. Test Integration: Query online Atoms
curl -s -X POST \
  "https://api.boomi.com/api/rest/v1/YOUR_ACCOUNT_ID/Atom/query" \
  -H "Content-Type: application/json" \
  -H "Authorization: Basic $(echo -n 'ACCOUNT_ID\USERNAME:PASSWORD' | base64)" \
  -d '{"QueryFilter":{"expression":{"operator":"EQUALS","property":"status","argument":["ONLINE"]}}}'

# Expected: {"@type":"QueryResult","result":[{"@type":"Atom","status":"ONLINE",...}]}

# 2. Test Flow: Check flow state (requires ManyWhoTenant header)
curl -s -X GET \
  "https://flow.manywho.com/api/draw/1/flow" \
  -H "ManyWhoTenant: YOUR_TENANT_ID" \
  -H "Authorization: Bearer YOUR_TOKEN"

# Expected: List of available flows in your tenant
```

## Data Mapping

### Flow-to-Integration Data Handoff

| Flow Concept | Integration Equivalent | Transform | Gotcha |
|---|---|---|---|
| Flow Value (ContentString) | Document property (String) | Direct | Flow strings are UTF-8; Integration XML profile may need encoding config |
| Flow Value (ContentNumber) | Document property (Number) | Direct | Flow uses JSON number type; Integration uses configurable numeric profiles |
| Flow Value (ContentDateTime) | Document property (DateTime) | ISO 8601 | Flow stores UTC; Integration date format depends on connector profile |
| Flow Value (ContentBoolean) | Document property (Boolean) | Direct | Flow uses true/false; some Integration connectors expect 1/0 or Y/N |
| Flow Value (ContentList) | Document (multiple records) | Split/join | Flow lists are JSON arrays; Integration processes XML documents -- split into individual docs |
| Flow Object | Document (XML/JSON structure) | Map shape | Flow objects have flat structure; Integration may need nested XML mapping |
| Flow File | Document attachment | Binary passthrough | Flow file uploads go through AWS S3; Integration receives as base64 or binary stream |

### Data Type Gotchas

- Flow's ContentList type maps to a JSON array, but Integration's internal format is XML. The AtomSphere Service Connector handles this conversion, but deeply nested lists may flatten unexpectedly. [src3, src4]
- Flow dates are always UTC. If Integration writes to a system with timezone-aware fields (Salesforce, SAP), ensure timezone conversion happens in the Integration Map shape, not in Flow.
- Flow file attachments are stored in AWS S3 within the Flow region. When Integration needs the file, it fetches from S3 via the service connector -- large files may slow the handoff.

## Error Handling & Failure Points

### Common Error Scenarios

| Scenario | Module | Cause | Resolution |
|---|---|---|---|
| Flow service connector timeout | Flow + Integration | Integration process exceeds 30s (Low Latency) | Switch Integration process to General mode; use async pattern with callback |
| Flow IdP login failure | Flow | Identity provider misconfigured or down | Verify IdP settings in Tenant > Identity Providers; check IdP status |
| Integration document rejected | Integration | Document exceeds 1 MB on Cloud runtime | Use self-hosted Atom or reference-fetch pattern |
| Flow state data loss | Flow | AWS region outage (rare) | Flow uses Aurora with multi-AZ replication; report to Boomi support [src3] |
| Service connector auth failure | Flow | Boomi API credentials expired or changed | Update credentials in Flow service configuration |
| Integration execution not found | Flow | Wrong Atom/process ID in service connector | Verify process is deployed to the specified Atom and the process ID matches |

### Failure Points in Production

- **Flow-to-Integration timeout mismatch**: Flow expects a synchronous response from Integration. If the Integration process runs in Low Latency mode (30s limit) and takes longer, the entire Flow step fails. Fix: `Use async pattern -- Integration returns 202 Accepted immediately, processes in background (General mode), and calls back to Flow when done`. [src5]
- **Identity provider token expiry during long workflows**: Multi-step flows that span hours or days can lose user session state if the IdP token expires. Fix: `Configure refresh tokens in the IdP setup; use Flow's built-in session management to re-authenticate on resume`. [src6]
- **Data format mismatch on service connector**: Flow sends JSON; Integration expects XML (internal format). The connector handles conversion, but custom profiles may fail on complex nested structures. Fix: `Use a dedicated Integration process with a JSON profile for Flow-facing endpoints instead of reusing XML-based processes`.
- **Flow regional routing errors**: Accessing a flow from a region different from where the tenant is hosted can cause latency or routing failures. Fix: `Use the correct regional URL (US, EU, AU) for player links; configure CDN for static flow assets`. [src3]

## Anti-Patterns

### Wrong: Using Integration to build user-facing approval workflows

```
# BAD -- Building approval UI in Integration
# Integration has no user-facing UI capability
Process: Listener --> Check Rules --> Send Email "Click here to approve"
  --> Poll inbox for response --> Update ERP
# Result: Poor UX, email-based approvals are unreliable, no audit trail
```

### Correct: Use Flow for approvals, Integration for data operations

```
# GOOD -- Separation of concerns
Flow: Start --> Approval Form (manager) --> Decision (approved/rejected)
  --> If approved: AtomSphere Service Connector --> Integration Process
Integration Process: Receive approved data --> Update ERP --> Update CRM --> Return result
Flow: Display confirmation to user
# Result: Rich UI, proper audit trail, reliable approval routing
```

### Wrong: Using Flow for complex ETL / data transformation

```
# BAD -- Trying to transform data in Flow
Flow: Start --> Service Connector (fetch CSV from SFTP)
  --> Attempt field mapping in Flow logic
  --> Service Connector (write to Salesforce)
# Result: Flow has no Map shape, no data profiling, no batch processing
# This will fail or produce incorrect data
```

### Correct: Use Integration for ETL, Flow only if humans need to trigger/monitor

```
# GOOD -- Integration handles all data work
Option A (no human involvement):
  Integration: Scheduler --> SFTP Read --> Map/Transform --> Salesforce Write

Option B (human trigger needed):
  Flow: User clicks "Start Import" button
    --> AtomSphere Service Connector
  Integration: Receive trigger --> SFTP Read --> Map --> Salesforce Write --> Return results
  Flow: Display import results to user
```

### Wrong: Deploying Flow for on-premise data residency requirements

```
# BAD -- Assuming Flow can run on-premise
# Flow is cloud-only (AWS VPCs). Sensitive data processed in Flow
# traverses Boomi's cloud infrastructure.
# This violates on-premise data residency requirements.
```

### Correct: Use Integration (self-hosted Atom) for on-premise data, Flow only for UI if cloud is acceptable

```
# GOOD -- Self-hosted Integration for on-premise data
Integration: Self-hosted Atom/Molecule (on-premise)
  --> Data stays within your network
  --> Connects to on-premise databases, file shares, ERP systems

If you also need a workflow UI:
  Flow: Cloud-hosted forms (non-sensitive data only)
    --> AtomSphere Service Connector calls on-premise Atom
    --> Sensitive data processed on-premise, only metadata returned to Flow
```

## Common Pitfalls

- **Treating Flow and Integration as interchangeable**: They solve fundamentally different problems. Integration = data movement/transformation. Flow = human workflow automation. Choosing the wrong one leads to awkward workarounds. Fix: `Use the decision tree: human interaction needed = Flow; data operations = Integration; both = connect them via service connector`. [src1, src2]
- **Not configuring an identity provider in Flow**: Without an IdP, published flows are accessible to anyone with the player URL. Fix: `Always configure at least one identity provider (OAuth 2.0, OIDC, or SAML) in Tenant settings for production flows`. [src6]
- **Ignoring the 30-second timeout on combined Flow+Integration calls**: Flow's service connector to Integration uses synchronous HTTP calls. If the Integration process exceeds 30 seconds (Low Latency mode), the entire flow step fails. Fix: `Use async pattern: Integration returns 202 immediately, processes in General mode (no timeout), calls back to Flow when complete`.
- **Assuming Flow can handle large data volumes**: Flow is designed for workflow state management, not data processing. Pushing thousands of records through Flow values degrades performance. Fix: `Process data volumes in Integration; pass only IDs and metadata to Flow for display and decisions`.
- **Deploying both when only one is needed**: Using Flow + Integration adds architectural complexity and cost. Many use cases need only one module. Fix: `If the process is fully automated with no human steps, use Integration alone. If it is a simple form/approval with no data transformation, use Flow alone`.
- **Not selecting the correct Flow region**: Flow tenant region cannot be changed after creation. Selecting the wrong region causes latency and may violate data residency requirements. Fix: `Choose the Flow region closest to your users at tenant creation time. For EU compliance, select the EU region`. [src3]

## Diagnostic Commands

```bash
# Check Integration Atom status (verifies Integration side is operational)
curl -s -X POST \
  "https://api.boomi.com/api/rest/v1/ACCOUNT_ID/Atom/query" \
  -H "Content-Type: application/json" \
  -H "Authorization: Basic BASE64_CREDS" \
  -d '{"QueryFilter":{"expression":{"operator":"EQUALS","property":"status","argument":["ONLINE"]}}}'

# List deployed Integration processes
curl -s -X POST \
  "https://api.boomi.com/api/rest/v1/ACCOUNT_ID/ProcessSchedules/query" \
  -H "Content-Type: application/json" \
  -H "Authorization: Basic BASE64_CREDS" \
  -d '{"QueryFilter":{}}'

# Check Flow tenant health (verify Flow side is accessible)
curl -s -X GET \
  "https://flow.manywho.com/api/draw/1/flow" \
  -H "ManyWhoTenant: YOUR_TENANT_ID" \
  -H "Authorization: Bearer YOUR_FLOW_TOKEN"

# Test Flow-to-Integration service connector
# This verifies the AtomSphere Service Connector can reach your Integration process
curl -s -X POST \
  "https://YOUR_ATOM_URL/ws/rest/YOUR_API/v1/test" \
  -H "Content-Type: application/json" \
  -H "Authorization: Basic BASE64_CREDS" \
  -d '{"test": true}'
```

## Version History & Compatibility

| Release | Date | Status | Key Changes | Impact on AtomSphere vs Flow |
|---|---|---|---|---|
| January 2026 | 2026-01 | Current | Secrets Management enhancements; AgentStudio improvements | Integration: improved credential management |
| November 2025 | 2025-11 | Supported | Flow runtime stability improvements | Flow: better auto-scaling behavior |
| September 2025 | 2025-09 | Supported | Runtime bug fixes | Minor |
| July 2025 | 2025-07 | Supported | Event Streams GA; Data Catalog enhancements | Integration: new event-driven option |
| 2024 | Various | Supported | AgentStudio launch; Rivery acquisition (CDC/ELT) | Integration: added change data capture |

### Deprecation Policy

Both Integration and Flow follow Boomi's bi-monthly release cycle. Flow was originally developed by ManyWho (acquired by Boomi in 2020) and has been progressively integrated into the Boomi platform. The legacy ManyWho API endpoints (flow.manywho.com) are still operational but may be deprecated in favor of unified Boomi endpoints. Monitor release notes for any migration requirements. [src3]

## When to Use / When Not to Use

| Use When | Don't Use When | Use Instead |
|---|---|---|
| You need human-in-the-loop workflows (approvals, forms, task routing) | The process is fully automated system-to-system | Boomi Integration (AtomSphere) only |
| You need both data integration AND human workflows | You need only data integration with no human involvement | Boomi Integration (AtomSphere) only |
| You need low-code app development for employees or customers | You need complex ETL or data transformation | Boomi Integration for ETL |
| Your process requires identity provider integration (SSO for end-users) | You need on-premise data residency for all data | Boomi Integration with self-hosted Atom |
| You want to automate multi-step business processes with decision logic | You need B2B/EDI or trading partner management | Boomi Integration (Enterprise) |
| You need a customer-facing portal or self-service application | You need Master Data Hub or data governance | Boomi Integration (Enterprise) |

## Cross-System Comparison

| Capability | Boomi Integration (AtomSphere) | Boomi Flow | MuleSoft Anypoint | Microsoft Power Automate |
|---|---|---|---|---|
| **Type** | iPaaS (data integration) | Low-code workflow | iPaaS (data integration) | Low-code workflow + RPA |
| **Data transformation** | Full (Maps, scripting) | None | Full (DataWeave) | Limited (expressions) |
| **Human workflows** | None | Full (forms, approvals) | None | Full (forms, approvals, RPA) |
| **Self-hosted runtime** | Yes (Atom/Molecule) | No | Yes (Mule Runtime) | No (cloud-only for workflows) |
| **Connector count** | 200+ | Service connectors (REST) | 400+ | 1000+ (pre-built) |
| **Coding required** | Low (visual + Groovy) | Very low (drag-and-drop) | Medium (DataWeave DSL) | Very low (visual) |
| **B2B/EDI** | Yes (Enterprise) | No | Yes | No |
| **Typical pricing** | $15K-100K+/yr (connector-based) | Included in Enterprise Platform or per-user | $50K-200K+/yr | $15/user/mo (per-user) |
| **Best for** | Multi-system integration, ETL | Approval workflows, portals | Complex enterprise integration | Office 365-centric workflows |

## Important Caveats

- Flow was originally built by ManyWho (acquired 2020). Some documentation and API endpoints still reference "manywho.com" URLs. These are functional but may be migrated to boomi.com domains in future releases. [src3]
- Flow pricing varies depending on whether it is purchased as part of the Enterprise Platform bundle (included) or standalone (per-user). Contact Boomi for specific pricing. [src8]
- The AtomSphere Service Connector in Flow requires Boomi Integration credentials with API access. Ensure the integration user has appropriate permissions for the processes Flow needs to invoke.
- Flow's cloud-only architecture means all workflow data passes through Boomi's AWS infrastructure. For regulated industries (healthcare, finance), verify that Boomi's compliance certifications (SOC 2, ISO 27001, HIPAA) meet your requirements.
- This comparison is current as of March 2026. Boomi's bi-monthly release cycle means capabilities evolve rapidly. Always verify against current release notes.

## Related Units

- [Boomi AtomSphere Platform Capabilities, Limits & Pricing](/business/erp-integration/boomi-atomsphere-capabilities/2026) -- detailed Integration module limits and pricing
- [MuleSoft Anypoint Platform Capabilities](/business/erp-integration/mulesoft-anypoint-capabilities/2026) -- competing iPaaS platform
- [Workato Integration Capabilities](/business/erp-integration/workato-capabilities/2026) -- alternative iPaaS platform