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.
• Key limit: Flow has no data transformation engine (no maps, no ETL) — it delegates to Integration via the AtomSphere Service Connector. Integration has no user-facing UI — it delegates to Flow for forms and approvals.
• 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.
• 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.
• 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.

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.

API Surfaces & Capabilities

Rate Limits & Quotas

Boomi Integration Limits

Boomi Flow Limits

Authentication

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

• 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.
• 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.
• 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.
• Flow regional data residency: Flow data is stored in the selected AWS region. Cross-region flow execution is not supported — you must select the region at tenant creation.
• Combined usage requires connector configuration: Using Flow + Integration together is not automatic. You must explicitly create an AtomSphere Service Connector in Flow.
• Licensing: Flow is included in the Enterprise Platform bundle but may require per-user licensing for external-facing flows.

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
|   +-- 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 --> Service Connector --> Integration --> target systems
+-- Does the process need on-premise execution?
|   +-- YES --> Boomi Integration only (Atom/Molecule); 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

Quick Reference

Capability Comparison

Use Case Matrix

Step-by-Step Integration Guide

1. Determine which module you need

Evaluate your requirements against the decision tree. The key differentiator: does a human need to interact with the process? [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.

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

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. [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
   - 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.

Code Examples

JSON: Flow service connector configuration

{
  "serviceName": "EmployeeOnboarding-Integration",
  "serviceType": "AtomSphere",
  "connection": {
    "atomSphereUrl": "https://api.boomi.com",
    "accountId": "YOUR_BOOMI_ACCOUNT_ID",
    "username": "[email protected]",
    "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

# 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

# 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"]}}}'

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

Data Mapping

Flow-to-Integration Data Handoff

Data Type Gotchas

• Flow's ContentList type maps to a JSON array, but Integration's internal format is XML. The service connector handles conversion, but deeply nested lists may flatten unexpectedly. [src3, src4]
• Flow dates are always UTC. If Integration writes to a timezone-aware system, ensure 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.

Error Handling & Failure Points

Common Error Scenarios

Failure Points in Production

• Flow-to-Integration timeout mismatch: Flow expects a synchronous response. 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 immediately, processes in background (General mode), and calls back to Flow when done. [src5]
• Identity provider token expiry during long workflows: Multi-step flows spanning hours can lose session state if the IdP token expires. Fix: Configure refresh tokens in 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. Custom profiles may fail on complex nested structures. Fix: Use a dedicated Integration process with a JSON profile for Flow-facing endpoints.
• Flow regional routing errors: Accessing a flow from a different region can cause latency or routing failures. Fix: Use the correct regional URL for player links; configure CDN for static flow assets. [src3]

Anti-Patterns

Wrong: Using Integration to build user-facing approval workflows

# BAD -- 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 --> Outcome
  --> If approved: AtomSphere Service Connector --> Integration Process
Integration: Receive data --> Update ERP --> Update CRM --> Return result
Flow: Display confirmation to user

Wrong: Using Flow for complex ETL / data transformation

# BAD -- Flow has no Map shape, no data profiling, no batch processing
Flow: Start --> Service Connector (fetch CSV) --> Attempt field mapping in Flow
  --> Service Connector (write to Salesforce)
# Result: 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" --> 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 -- 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

# GOOD -- Self-hosted Integration for on-premise data
Integration: Self-hosted Atom/Molecule (on-premise)
  --> Data stays within your network

If you also need a workflow UI:
  Flow: Cloud-hosted forms (non-sensitive data only)
    --> 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. Fix: Use the decision tree: human interaction = Flow; data operations = Integration; both = connect via service connector. [src1, src2]
• Not configuring an identity provider in Flow: Without an IdP, flows are accessible to anyone with the URL. Fix: Always configure at least one IdP for production flows. [src6]
• Ignoring the 30-second timeout on combined Flow+Integration calls: Flow's service connector uses synchronous HTTP calls. Fix: Use async pattern: Integration returns 202 immediately, processes in General mode, calls back when complete.
• Assuming Flow can handle large data volumes: Flow is designed for workflow state, not data processing. Fix: Process data volumes in Integration; pass only IDs and metadata to Flow.
• Deploying both when only one is needed: Adds unnecessary complexity and cost. Fix: If fully automated with no human steps, use Integration alone. If simple form/approval, use Flow alone.
• Not selecting the correct Flow region: Tenant region cannot be changed after creation. Fix: Choose the region closest to your users at creation time. [src3]

Diagnostic Commands

# Check Integration Atom status
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
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
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

When to Use / When Not to Use

Cross-System Comparison

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.
• Flow pricing varies depending on whether purchased as part of the Enterprise Platform bundle (included) or standalone (per-user). Contact Boomi for specific pricing.
• The AtomSphere Service Connector in Flow requires Boomi Integration credentials with API access. Ensure the integration user has appropriate permissions.
• Flow's cloud-only architecture means all workflow data passes through Boomi's AWS infrastructure. For regulated industries, verify Boomi's compliance certifications (SOC 2, ISO 27001, HIPAA).
• This comparison is current as of March 2026. Boomi's bi-monthly release cycle means capabilities evolve rapidly. Always verify against current release notes.