Building integrations should be fast, efficient, and adaptable — enabling teams to automate processes without unnecessary complexity. With Celigo’s March release, the new Flow Builder introduces a modern UI, improved navigation, and new productivity features to enhance usability and performance.

Designed for both business users and developers, the new Flow Builder simplifies integration development with smarter automation, reusable components, and built-in error handling. These enhancements make it easier than ever to connect applications and streamline workflows.

What’s new?

• Compact view optimizes screen space, reducing clutter while keeping essential tools accessible.
• Redesigned tool menu helps users quickly find the right options without searching through multiple menus.
• Clone option allows users to duplicate any step instantly, eliminating the need for manual rebuilding.
• Flow step bottom bar provides a clearer view of attached tools, making it easier to track modifications.
• Simplified branch merge/unmerge options for easier branch management.
• Refreshed icons and a cleaner UI create a more polished, modern experience.
• New UI toggle lets users switch between the classic and updated experience at their own pace. The new and classic UIs are fully compatible, so you can switch back and forth without losing work. 

Flow Builder demo

A smarter way to build integrations

At the core of Flow Builder is its visual programming model, which allows users to:

• Drag and drop integration steps
• Define logic without writing code
• Connect applications efficiently

Every flow is structured and interactive, providing a real-time view of how data moves across systems. Instead of manually configuring each step, users can leverage prebuilt templates, reusable components, and guided interactions to build integrations faster and more accurately.

Flow Builder also takes a data-driven approach to integration. Users can preview how data flows between applications at any stage, ensuring transformations work as expected before deployment. Real-time validation eliminates guesswork so that users can troubleshoot and refine integrations instantly.

AI and automation reduce complexity

Flow Builder simplifies integration development with AI-powered tools that assist with field mapping and scripting:

• AI code assistants generate JavaScript, SQL, SOQL, GraphQL, and Handlebars transformations based on natural language descriptions.
• Reusable components eliminate redundant work—any integration step (export, import, mapping, script) can be repurposed across multiple flows, reducing setup time and ensuring consistency.

For example, if a team builds a flow to sync customer records between NetSuite and Salesforce, they can reuse that same transformation logic for other integrations without rebuilding it from scratch.

Built-in error handling

Managing integration errors can be time-consuming and complex, often requiring custom logic and manual troubleshooting.

Celigo’s Flow Builder eliminates this burden with built-in exception management that proactively detects, categorizes, and resolves errors, keeping workflows running smoothly.

• Automatic error resolution reduces disruptions by retrying failed records due to server-side issues like API rate limits or network timeouts.
• Proactive issue detection flags errors such as missing fields or misconfigured data, ensuring nothing goes unnoticed.
• Exception management dashboard enables users to categorize, assign, and track errors to streamline resolution and improve visibility.

A more streamlined, intuitive experience

The Flow Builder is the most powerful, user-friendly integration experience available. With an intuitive visual approach, AI-powered assistance, built-in error handling, and a streamlined UI, Celigo enables teams to build integrations faster, with less effort, and greater accuracy.

Learn more about the new Flow builder user interface →

Lookup Caches act as a central repository for frequently used data, stored in a key-value format. This allows you to store, find, and reuse data across flows without relying on repeated API calls or external database queries.

→ Learn more about the Lookup Cache.

Lookup Cache demo

Lookup Cache overview

Why use Lookup Caches in your flows?

• Faster data lookups: Reduces dependencies on external systems, improving flow efficiency.
• Scalable mappings: Handles large datasets better than static or dynamic lookups.
• Reusable and flexible: Acts as a lookup table, environment-specific variable store, or centralized reference data repository.
• Easier maintenance: Data can be loaded via CSV files or updated dynamically using Integrator.io APIs.

Many integrations require mapping and transforming data between different formats.

For example:

• One system may store country and state data as two-letter codes, while another requires full names.
• Maintaining these mappings manually is time-consuming, error-prone, and difficult to scale, especially with large datasets.

A Lookup Cache solves these challenges by storing transformation rules centrally, ensuring faster, more reliable, and scalable mappings.

Use case: Mapping country codes to full names

Imagine syncing customer data from Microsoft Dynamics 365 Business Central to Shopify:

• Business Central stores country and state information as two-letter codes.
• Shopify requires full country and state names.

Instead of relying on:

• Static lookups, which are difficult to maintain
• External API calls, which slow down processing

You can use Lookup Cache to transform values within your integration instantly.

How to use Lookup Cache for mappings

Step 1: Configure the mapper

• Open Mapper 2.0 in your flow.
• Select the destination field (e.g., “Country” in Shopify).
• Select the source field (e.g., “Country Letter Code” from Business Central).

Step 2: Create a Lookup Cache

• Change the field mapping type to Lookup and select Lookup Cache.
• If an existing Lookup Cache is available, select it. Otherwise, create a new one.
• Upload a CSV file containing mappings for two-letter country codes and full names.
• Choose the key column (e.g., “Alpha-2” for two-letter country codes).
• Choose the value column (e.g., “Full Country Name”).
• Configure whether the data should persist when cloning or moving the flow.

Step 3: Apply the Lookup Cache in the mapper

• Select Lookup Cache as the mapping source.
• Set the value field to return the full country name.
• Save and apply the changes.

Step 4: Run the flow and verify the data

• Execute the flow to sync customer records.
• In Shopify, confirm that country names now appear in full instead of two-letter codes.

Benefits of using the Lookup Cache

Lookup Cache provides a scalable, efficient solution for transforming large datasets in integrations. Storing and applying mappings improves accuracy, reduces reliance on external systems, and accelerates data processing.

• Faster processing: Avoids repeated API calls for lookups.
• Scalability: Handles large datasets without performance issues.
• Easy maintenance: Update lookup values centrally without modifying each flow.
• Greater accuracy: Eliminates errors from manual mappings.

→ Learn more about the Lookup Cache.

In an iPaaS, concurrency is the platform’s ability to execute multiple tasks, processes, or workflows simultaneously. This enables integrations to run in parallel, efficiently managing overlapping operations such as concurrent API calls and large data transfers. By dividing workloads into smaller, parallel units, concurrency enhances performance, speeds up processing, and optimizes resource utilization.

Think of concurrency like a highway system. Without it, data moves along a single-lane road, forcing each task to wait for the one ahead, leading to slowdowns and bottlenecks. With concurrency, the system expands into a multi-lane highway, allowing multiple processes to run simultaneously, reducing congestion and improving speed. Just as traffic signals optimize vehicle flow, concurrency ensures efficient resource allocation, keeping integrations running smoothly without unnecessary delays.

Managing concurrency is critical for high-volume data processing. The right configuration speeds up data synchronization, prevents API throttling, and ensures consistent performance. Poorly managed concurrency, on the other hand, leads to delays, resource limits, and missed SLAs.

Here, we’ll explore how Celigo’s tools help you configure, monitor, and scale concurrency settings to keep your integrations fast, efficient, and reliable—even under heavy workloads.

Key benefits of concurrency management

1. Enhanced performance and speed
   Processing tasks in parallel significantly reduces workflow completion times.
   • Example: Syncing 10,000 records with concurrency set to five threads can be five times faster than processing one record at a time.
2. Improved scalability
   Concurrency ensures systems can handle growing data volumes without performance degradation, adapting to the demands of scaling businesses.
3. Reduced latency for time-sensitive workflows
   Processes like inventory synchronization or payment processing benefit from concurrency by minimizing delays and meeting real-time requirements.
4. Optimized resource utilization
   Concurrency ensures efficient use of system resources, minimizing idle time and maximizing throughput.
5. Support for complex workflows
   Concurrent processing enables businesses to handle interdependent tasks, such as syncing parent and child records, without bottlenecks.
6. Compliance with API governance
   Configuring concurrency appropriately helps avoid exceeding API rate limits, prevent throttling errors, and maintain consistent system performance.

Examples of concurrency in an iPaaS

• Ecommerce order processing
  Concurrency allows multiple customer orders to be processed simultaneously, syncing with an ERP system in parallel. This prevents bottlenecks and ensures timely order fulfillment, even during peak sales periods.
• Real-time inventory updates
  Concurrency enables parallel API calls across multiple platforms (ERP, marketplaces, and warehouse management systems), significantly reducing the time required to update stock levels in real-time and preventing overselling and discrepancies.
• Employee onboarding automation
  When a new employee is hired, concurrency allows multiple onboarding tasks (such as account creation, payroll setup, and software access provisioning) to be processed simultaneously across different systems, accelerating the onboarding experience and reducing manual delays.

Core principles of concurrency in iPaaS

• Parallel process execution
  Execute multiple workflows or tasks simultaneously while efficiently managing resources to prevent contention and performance degradation.
• Dynamic workload scaling
  Automatically scale workloads up or down in response to demand, leveraging cloud-based architectures to optimize resource allocation for concurrent processes.
• Error management and resilience
  Isolate and handle errors within concurrent processes independently, preventing failures from cascading and ensuring uninterrupted workflow execution.
• Throughput and latency optimization
  Maximize data throughput while minimizing latency to maintain high-speed, efficient processing, even under heavy concurrent workloads.

Best practices for managing large data volumes

Optimize flow design

• Partition data intelligently: Break down large datasets into logical segments (e.g., geographic regions, product categories) to enable parallel processing and reduce load on individual API calls.
• Use prebuilt templates: Leverage Celigo’s preconfigured templates to streamline integration setup for common use cases.
• Example: Partitioning order data by region (e.g., North America, EMEA, APAC) helps distribute processing load, reduces API throttling risks, and improves overall runtime efficiency.

Configure concurrency settings effectively

Tailor concurrency settings to align with system capacity and API rate limits to optimize performance.

Steps to configure:

1. Review API rate limits and thresholds: Check API documentation for rate limits, batch processing capabilities, and recommended concurrency settings.
2. Set connection concurrency: Configure concurrency levels to match the API’s processing capacity without exceeding limits.
3. Validate in a sandbox:  Test configurations in a non-production environment to prevent disruptions in live operations.

Enable delta data processing

Delta processing improves efficiency by syncing only modified or newly created records, reducing API usage and processing time.

How to configure:

1. Create a filter:  Define conditions to extract only records updated since the last successful sync.
2. Activate delta processing:  Enable delta settings in the flow configuration to track and process incremental changes.
3. Validate results:  Compare synced records against source logs to confirm accuracy.

Monitor and scale dynamically

• Use Celigo’s monitoring tools to track key performance metrics such as execution time, error rates, and throughput.
• Scale runtime resources dynamically based on data volume fluctuations, ensuring smooth operations during peak loads.

Leverage parallel flows

• Running datasets through multiple concurrent flows reduces runtime while maintaining system stability.
  • Example: Instead of processing all inventory data in a single flow, split it by product categories (e.g., electronics, apparel) to prevent bottlenecks and improve processing speed.

Celigo’s approach to concurrency

Celigo provides powerful tools to configure, monitor, and scale workflows, delivering reliable performance even under high-volume demands.

Key features include:

Dynamic paging and parallel processing

• What it does: Divides large datasets into smaller, manageable chunks for parallel execution, reducing processing time and system strain.
• Benefits: Optimizes API efficiency, minimizes load on target systems, and improves data throughput.
• Example: Adjusting Salesforce SOQL query page sizes to 200–1000 records balances performance while preventing timeouts and API rate limit violations.

AI-powered optimizations

• Predictive monitoring: AI continuously analyzes historical and real-time data to detect anomalies and suggest proactive adjustments, preventing issues like API throttling.
  • Example: If API usage nears rate limits, Celigo recommends reducing thread counts or increasing throttle delays to maintain smooth processing.
• Dynamic scaling insights: AI optimizes key settings such as page sizes, thread counts, and throttle delays based on actual workload patterns, ensuring workflows automatically adapt to peak loads.

Built-in exception management

• Automated retries: Resolves transient errors  (e.g., timeouts, temporary API outages) without manual intervention.
  • Example: A network outage triggers automatic retries, preventing workflow disruptions.
• Detailed error logs: Captures persistent issues (e.g., invalid credentials, permission errors) for manual review.
• Tagging and assignment: Classifies exceptions by type and assigns them to the appropriate team members for faster resolution.

Connection-level concurrency controls

• What it does: Configures concurrent API requests to maximize throughput while preventing throttling.
• Example: If an API has a 60-requests-per-minute limit, Celigo can limit concurrency to 5 requests with a 1-second throttle delay, ensuring efficient and compliant execution.

Preserving record order

For workflows requiring sequential data processing, Celigo’s Preserve Record Order feature ensures data integrity, making it ideal for:

• Financial transactions (e.g., invoice processing)
• Parent-child relationships (e.g., hierarchical customer or product data)

Elastic scalability

• What it does: Celigo’s cloud-native infrastructure dynamically scales to handle workload spikes, ensuring consistent performance without manual intervention.
• Powered by:
  • Amazon SQS – Efficient message queuing for parallel processing
  • Amazon S3 – Secure and scalable storage for large datasets
  • MongoDB – High-performance data persistence for fast retrieval

Recommended concurrency settings for common scenarios

Customization may be required based on the specific API or workload, and regular monitoring is essential for maintaining optimal performance.

Beyond performance tuning, proactive error management helps detect and address potential issues before they escalate. Automated alerts can notify teams of problems, such as exceeding API rate limits or connection failures due to high request volumes, allowing immediate action to prevent disruptions.

Maximize throughput and keep data flowing

Effective concurrency management is essential for optimizing large data volume processing in an iPaaS. By configuring parallel execution, leveraging AI-driven optimizations, and implementing robust exception handling, organizations can achieve higher throughput, reduced latency, and seamless scalability.

By following these best practices, teams can ensure smooth, efficient, and resilient integrations—even under the most demanding data conditions.

Additional concurrency resources

• • Optimize multiple connections in your Integration App flows to improve throughput
  • Preserve the order of records when using concurrency
  • Optimize throughput & governance by configuring connections’ concurrency levels

Celigo’s multi-environment feature enables organizations to configure and manage multiple environments (e.g., development, testing, QA, staging, production) to support their software development lifecycle (SDLC) and DevOps workflows.

Multi-environment demo

Key benefits of multi-environment support

These features enable organizations to configure, manage, and optimize multiple environments for a smoother development lifecycle.

Custom environment setup – Configure environments based on DevOps, CI/CD, and testing needs.

Improved access control and security – Assign user roles and permissions per environment for better governance.

Seamless deployment and promotion – Clone and promote integrations, flows, and resources across environments.

Scalability and flexibility – Supports enterprise-grade version control and release management for complex workflows.

Exploring key benefits

By leveraging multi-environment support, organizations can enhance efficiency, reduce risk, and improve governance across their integration processes.

Proactive workflow management – Isolate development, testing, and production to prevent disruptions and ensure stability.

Streamlined governance – Apply consistent policies to maintain data integrity, security, and compliance.

Efficient resource utilization – Scale workflows based on demand and free up resources by enabling/disabling environments as needed.

Step 1: Navigate to the multi-environment dropdown

• Upon logging into Celigo, you’ll see a new dropdown menu in the top-right corner.
• This replaces the old production/sandbox toggle and lists all available environments (e.g., production, dev, QA, staging).
• Select any environment to access it directly.

Step 2: Review environment entitlements

• Navigate to Subscription → Environments to check your entitlements.
• Your plan determines how many environments you can create.
  • Example: An enterprise plan may allow three environments, with one active.
• Additional environments can be purchased for professional or standard plans.

Step 3: Enable or disable environments

• Go to the environments tab to view all available environments.
• Production is always enabled by default.
• Toggle environments (e.g., test, UAT, dev) on or off as needed.
• If you’ve reached your limit, you can:
  • Disable an existing environment
  • Upgrade your plan to increase entitlements

Step 4: Create a new environment

• Go to Environments → Click “Create Environment.”
• Enter a name (e.g., “Performance”) and an optional description.
• Save the environment (it starts in a disabled state).
• Enable the environment if entitlements are available.
  • If entitlements are exceeded, the system will notify you.

Step 5: Manage users and permissions

• Navigate to the user’s section within each environment to invite or manage user roles.
• Environment-specific access: Invite users to non-production environments with specific roles (e.g., admin, monitor, developer).
• Production admin access: If a user is assigned admin in production, they automatically gain access to all non-production environments.
• Admin access to a non-production environment does not extend to production unless explicitly granted.

Key points to remember

• Entitlements dictate limits – Your production entitlements determine the maximum number of environments you can have.
• Each environment operates independently – While following the same entitlement structure, they function autonomously.
• Easy navigation – Quickly switch environments using the dropdown menu or the environments tab

Implementing a multi-environment strategy

By leveraging Celigo’s multi-environment feature, teams can streamline workflows, minimize risks, and accelerate time to production. With customizable access controls, seamless deployment options, and scalable resource management, organizations can optimize their integration processes and maintain operational efficiency at every stage.

Whether you’re managing a small team or an enterprise-level infrastructure, multi-environment support provides the flexibility and control needed to drive continuous innovation and growth.