Anyone switched from Profound to something else? Honest feedback

We used Profound for a few years to handle Shopify-to-NetSuite order syncs and basic CRM updates. It worked... until it didn't. The final straw was a mapping change that took their support two weeks to implement, costing us a sales promotion. The point-to-point nature felt brittle and the lack of real-time logging was a constant headache.

We evaluated two main paths: a full middleware platform vs. a dedicated API integration tool. Here's the same simple test we ran—connecting a Shopify webhook to create a customer in NetSuite—across three tools.

**The Prompt/Brief:**
"Build a flow that accepts a Shopify `customers/create` webhook, maps the incoming JSON to NetSuite customer fields (including custom fields for `customer_segment` and `acquisition_channel`), and posts to the NetSuite RESTlet. Handle basic error logging and retry logic."

**1. Profound (our baseline)**
```javascript
// Profound Logic: Mostly UI config, but custom logic looked like this
function onShopifyCustomerCreate(webhookData) {
var nsCustomer = {};
nsCustomer.companyName = webhookData.first_name + " " + webhookData.last_name;
nsCustomer.email = webhookData.email;
// Custom field mapping required a separate config screen
nsCustomer.custentity_segment = webhookData.tags; // Had to pre-configure 'tags' as a source
// Error handling was a separate "failure branch" UI
}
```
*Notes:* The UI forced a specific mapping structure. Custom logic was possible but felt bolted-on. The retry logic was a simple checkbox. No built-in way to see the *transformed* payload before NetSuite.

**2. Workato**
```ruby
# Workato Recipe: Code is from the "Formula" mode for a custom field.
{
"companyname": "#{input['first_name']} #{input['last_name']}",
"email": "#{input['email']}",
"custentity_segment": "#{input['tags']}",
"custentity_acquisition_channel": "Shopify"
}
```
*Notes:* The connector handled NetSuite custom fields natively—just pick from a list. The real-time recipe inspector showed the exact payload at every step. Retry logic was configurable per error type. The shift to a recipe/model felt like moving from duct tape to a proper framework.

**3. Celigo**
```javascript
// Celigo Integrator I/O mapping in "Advanced" mode
function map($in) {
var output = {};
output.companyName = $in.first_name + ' ' + $in.last_name;
output.externalId = 'shopify_' + $in.id;
// Custom fields available directly in the mapper UI, this is if you need logic
if ($in.tags && $in.tags.length > 0) {
output.customFields.custentity_segment = $in.tags.join(',');
}
return output;
}
```
*Notes:* Felt like a midpoint. Better than Profound's UI, but the logging wasn't as immediate as Workato's. The big plus was the pre-built Shopify-NetSuite flow templates, which cut our rebuild time drastically.

**Honest Feedback:**
We went with Workato. The API-led approach meant we could reuse connections (e.g., our NetSuite credential set) across other flows. The real debugging saved dozens of hours. It costs more, but the reduction in "integration fires" was worth it.

For simpler, point-to-point, maybe Celigo is enough. But if you're thinking beyond a single sync, the middleware platform pays off. Profound felt like custom scripting with a UI wrapper; we outgrew it.

Has anyone else made a similar jump? What was your breaking point with Profound, and did you land on a different tool?