Field note 06 / Integration design
Before you build the integration.
Native connector, automation platform, or custom integration?
Start with a supported connector if it meets the requirements. Use an automation platform when its steps can express the process clearly. Custom code needs a specific reason and someone prepared to maintain it.
I would want to see the existing options handle a few difficult records before recommending a build. An app listing tells you a connection exists. You still need to establish whether it supports your process.
The person maintaining it matters, too. A workflow that someone can understand, inspect, and repair is worth more than flexibility they have no capacity to use.
What are you taking responsibility for?
A native connector is a prebuilt connection supplied by one of the system vendors. Third-party connectors are another prebuilt option; check who supports them. An automation platform lets you assemble triggers, actions, and rules. A custom integration puts the implementation under your team's control.
These approaches can overlap. An automation can call a small custom service. The useful distinction is which behavior the provider supplies and which behavior your team must build and maintain.
| Approach | When I would consider it | What I would need to verify |
|---|---|---|
| Native or prebuilt connector | Its supported objects, mappings, and update rules match the process. | Record matching, sync direction, relationships, exclusions, and visibility into failures. |
| Automation platform | Available actions can express the process, and the team can follow the workflow. | Updates as well as creates, partial failures, safe replay, expected volume, and usage costs. |
| Custom integration | A demonstrated gap needs tailored processing or a connection the other options cannot provide. | API capabilities, tests, monitoring, recovery, deployment, and a named maintainer. |
Check the actual connection
For example, HubSpot data sync supports one-way or two-way synchronization with supported apps. Check the particular app's objects and mappings, along with the subscription requirements for the features you need.
A tool supporting both systems is a starting point. I would still ask it to demonstrate the required updates and relationships using representative records.
Try an order that changes
Consider an illustrative setup where an ERP order becomes a HubSpot deal with a company and line items. The ERP owns the order. Sales needs to see its current state in HubSpot. This is a decision exercise, not a customer case study.
Creating the first deal only covers the beginning. I would use the following cases to compare the options. The expected behavior here is an example agreement for this process.
- An order quantity changes from 10 to 8. Update the matching line item and affected totals on the existing deal.
- The ERP cancels the order. Apply the agreed cancellation status in HubSpot and preserve the order reference.
- The same notification arrives twice. Keep one deal and one intended set of line items.
- The deal is created, but attaching a line item fails. Identify the completed work and recover without creating another deal.
Let the missing behavior decide
If a connector passes those checks, its cost and support arrangements are acceptable, and the team can operate it, I would use it.
Now suppose the connector can create a deal but cannot apply the required line-item changes. That gives us a specific gap to investigate. An automation platform may cover it through its actions or API requests. I would try the change and recovery cases there before deciding it needs a separate service.
Custom code becomes a reasonable option if the remaining processing is difficult to express and maintain in that platform, or if its execution limits prevent the required behavior. It still depends on what the source and destination APIs allow. Code cannot supply a capability those systems do not expose.
Find out what replay repeats
Recovery deserves its own check. Zapier, for example, distinguishes replaying errored steps from replaying an entire run. A full replay runs previously successful steps again and can add task usage. Check which behavior you are relying on.
For the order example, ask what happens to the deal that already exists when the line-item step fails. The operator needs enough information to resume safely. A retry button does not establish whether repeating a create is safe.
Zapier documentation: replay Zap runs Before you retry that request.
When I would advise against custom code
I would push back on a custom build in these situations.
- A supported option already meets the requirements, including recovery. A preference for writing code is not a reason to replace it.
- The teams have not agreed which system owns the data or what conflicting updates mean. Those decisions are needed whichever tool you choose.
- The task is infrequent and a reviewed manual process costs less than building and maintaining an integration.
- Nobody can own monitoring, access changes, API changes, and repairs after launch. That work needs time and a budget.
Write down what the choice depends on
Before committing, I would keep a short decision record with enough detail for the next person to challenge it.
- The required behavior and the examples used to test it.
- The options tried, any gaps found, and the compromises accepted.
- Expected volume and delay, with costs for ordinary processing, retries, and catch-up runs.
- Who investigates failures, how they recover, and who maintains the connection.
- What would trigger a review, such as another system, higher volume, or a new update rule.
Notes from building integrations,
backend systems, and custom applications.