Bidirectional CRM Sync

When building sales, marketing, or CX-related SaaS applications, bi-directional CRM integrations are a must. This means supporting both pushing data to your users’ CRMs and staying up to date as records change in their CRM data within your application.

Building a bi-directional CRM sync in Paragon is quite easy and is implemented with:

1. Managed Sync for pulling potentially hundreds of thousands of records from your users’ CRM to your application, and staying up to date as updates occur in their CRM

2. Workflows for pushing records - both transactional or in bulk - from your application to your users’ CRMs

Initial Data Sync & Continuous Data Updates

Managed Sync is designed for performant data pulls from 3rd-party platforms like Salesforce, Hubspot, Dynamics, and other CRMs, with minimal configuration. In the Managed Sync world, Sync pipelines can pull all the CRM data across desired object types (Contacts, Leads, Accounts, Deals, etc.), across all your CRM integrations, and puts that data into normalized schemas. This makes it easy to use the same application logic to pull data across all of your CRM integrations.

No need to research CRM-specific APIs, understand API & webhook specific behaviors, and write integration specific logic. With Managed Sync, you can enable Sync pipelines with just one API across all the CRM integrations your product needs. You can enable syncs on-demand, such as when a new user enables one of you integrations. You can also configure Sync pipelines to run on a schedule (every day, month, or every few minutes for near-real-time data updates)

//Salesforce Sync
curl --request POST <https://managed-sync.useparagon.com/sync> \\
  --header 'Authorization: Bearer <token>' \\
  --data '{
  "integration": "salesforce",
  "pipeline": "crm",
  "configuration": {}
}'
//Hubspot Sync
curl --request POST <https://managed-sync.useparagon.com/sync> \\
  --header 'Authorization: Bearer <token>' \\
  --data '{
  "integration": "hubspot",
  "pipeline": "crm",
  "configuration": {}
}'
//Microsoft Dynamics Sync
curl --request POST <https://managed-sync.useparagon.com/sync> \\
  --header 'Authorization: Bearer <token>' \\
  --data '{
  "integration": "dynamics",
  "pipeline": "crm",
  "configuration": {}
}'

Now that we covered the benefits of Sync pipelines and how to enable a Sync pipeline, let’s cover the mechanics of the Sync API, using YourApp.ai to represent your sales application:

When your users first enable a sync, Managed Sync will ingest a full replica of your users’ CRM data, notify your application when the data is ready, and your services can pull the normalized data. From there, you can stay up to date with changes in your users' CRMs with the record_updated webhooks, making sure that your application has near-real-time data. Once you get the record_updated webhook, pull the record data with the same endpoint as the initial sync. So in total, there are only two endpoints you need to hit to enable full ingestions of every CRM's data!

Read through the Managed Sync docs to see how a few APIs can enable full data pulls across all of your users’ CRMs.

Data Pushing

Pushing records from your application to your users’ CRM can be done via Workflows. Paragon handles the API details for Salesforce or Hubspot like authentication and request parameters, so your developers can focus on the data needed for the API.

const triggerStep = new EndpointStep({
  objectMapping: `${context.getInput(this.inputs.custom_opportunity_object).record_type}`,
});

const actionStep = integration.actions.searchRecords(
  {
    recordType: 'Opportunity',
    filterFormula: Operators.StringExactlyMatches(
      'Name',
      triggerStep.output.request.body.opportunity_name,
    ),
  },
  {
    autoRetry: false,
    continueWorkflowOnError: false,
    description: 'Get Opportunity',
  },
);

const ifelseStep = new ConditionalStep({
  if: Operators.ArrayIsNotEmpty(actionStep.output.result.records),
  description: 'Does Opportunity Exist',
});

const actionStep1 = integration.actions.updateRecord(
  {
    recordType: 'Opportunity',
    'field-Name': ``,
    additionalFields: `${triggerStep.output.request.body}`,
    recordId: `${actionStep.output.result.records['0'].Id}`,
  },
  {
    autoRetry: false,
    continueWorkflowOnError: false,
    description: 'Update Opportunity Record',
  },
);

...

const actionStep2 = integration.actions.createRecord(
  {
    recordType: 'Opportunity',
    'field-Name': `${triggerStep.output.request.body.opportunity_name}`,
    additionalFields: `${triggerStep.output.request.body}`,
  },
  {
    autoRetry: false,
    continueWorkflowOnError: false,
    description: 'Create Opportunity Record',
  },
);

...

Within Paragon Workflows, your team can build out integration logic in Typescript representations of workflows via Paragraph or a low-code format in Paragon’s Workflow builder. Notice that the Typescript Workflow representation has full parity with the UI representation. In either case, you can implement logic like checking your users’ CRM to see if a record exists before creating a new record, all without having to read the 3rd-party API.

You can trigger Workflows by passing in the necessary CRM data to our API endpoints or event listeners. Either way, Workflows provide a flexible solution to implement robust pipelines for pushing data as Managed Sync pulls data.

Custom Fields and End-User Configurability

Working with CRM integrations, it's likely each of your customers will have custom schemas in their CRMs (or even your app), via custom fields and custom objects. The Sync API supports both custom CRM objects as well as custom fields for standard objects. Managed Sync’s normalized schema for a contact will look like this, with any custom fields included.

{
  "id": "<string>",
  "external_id": "<string>",
  "first_name": "<string>",
  "last_name": "<string>",
  "full_name": "<string>",
  "company_name": "<string>",
  "emails": [
    {
      "type": "primary",
      "email": "<string>"
    }
  ],
  ...
  "notes": "<string>",
  "website": "<string>",
  "custom_fields": {
	  "Budget": "<integer>",
	  "Authority": "<string>",
	  "Need": "<string>",
	  "Timing": "<string>",
  }
}

Bi-directional syncs between your users’ CRMs and your application means that these CRM records will need field mappings that your users will want control over. With Paragon’s embedded UI, your end-users can not only easily authenticate into their CRMs, but also define how they want data to map between your schema and their CRM schema.

On the right side are the fields in your application, and users can choose the fields in their CRM that should dynamically mapped to your fields. On the pull side you can pull those user configured mappings to map fields from your users’ CRM fields to your application.

{
	"mapObjectFields": {
		"Custom Opporunity Object": [
		  {
		    "label": "Budget",
		    "value": "budgeting__c"
		  },
		  {
		    "label": "Authority",
		    "value": "decision_making_level__c"
		  }, 
		  ...
		]
	}
}

On the push side, these configuration and custom field mappings also work perfectly in Workflows, where these field mappings can be applied on your data schemas when using the CRM-specific Workflow Actions.

Wrapping Up

As you can see, Paragon makes it easy to implement bi-directional sync functionality with your customers' CRMs. If you’d like to integrate with Salesforce, Hubspot, Dynamics, Pipedrive, Zoho, and every other CRM platform your customers are using, get started with

1. Managed Sync to handle heavy volume syncs and updates

2. Workflows to flexibly build data pipelines on Paragon’s infrastructure to push data on-demand

Get started now and book a demo with our team!