Systems Integration & API Development
ERP integration services for NetSuite, QuickBooks, Shopify and Stripe
We connect your ERP or accounting system to your store, payment platform and CRM, so an order, invoice or refund is entered once and matches everywhere it appears. Each flow gets the simplest tool that will hold up: a prebuilt connector, Celigo, n8n or custom code.
When systems don’t talk, people do the syncing
A growing company usually ends up with four sources of truth: the ERP or accounting system, the store or billing platform, the payment processor and the CRM. Each one is right about its own slice. The gaps between them get filled with CSV exports, copy-paste and a spreadsheet that one person understands.
That holds until order volume doubles or the person who runs the spreadsheet goes on holiday. Then orders go missing, payouts stop matching invoices, and month-end close stretches into the second week.
Often there’s already a connector in place. It handles the standard flow well and leaves the awkward 20 percent (partial refunds, bundles, multi-currency payouts, custom fields) for someone to fix by hand.
Signs this is costing you
- Someone re-keys Shopify orders or Stripe payments into NetSuite or QuickBooks.
- Payouts in Stripe never quite match the deposits your accountant sees.
- A nightly import fails and nobody notices until a customer calls.
- The connector covers most orders, and a person fixes the rest every morning.
- Revenue in HubSpot and revenue in the books are two different numbers.
How we approach it
Step 01
Decide who owns each record
Before any code, we list every object that moves (customers, items, orders, invoices, payments, refunds, payouts), which system is the master for each, and the field-by-field mapping. Most sync bugs are ownership disagreements that nobody wrote down.
Step 02
Pick the tool per flow, not per project
A standard Shopify order into NetSuite may be best served by an existing connector or Celigo. A refund rule unique to your business may need a small custom service. We recommend the cheapest option that will survive your volume and edge cases, and say plainly when you don’t need us to build anything.
Step 03
Design for the failures you’ll actually get
Webhooks arrive twice, APIs time out after doing the work, and vendors go down. Every write is idempotent, retries back off, and anything that still fails lands in a queue you can replay. A duplicate order or a silent gap is treated as a defect, not bad luck.
Step 04
Build and test against sandboxes
Development runs against a NetSuite sandbox, a Shopify development store, Stripe test mode and a HubSpot test portal, with your real edge cases turned into test data.
Step 05
Run old and new side by side
Historical data is backfilled in batches. Then the new integration runs alongside your current process until a reconciliation report shows the two agree, and only then does the manual work stop.
Connector, Celigo, n8n or custom code?
We choose per flow, not per project. This is the short version of the recommendation you get at the end of discovery.
| Prebuilt connector | Celigo | n8n | Custom code | |
|---|---|---|---|---|
| Best for | Standard flows at modest volume | A NetSuite-centred stack that will keep growing | A few flows your team wants to see and adjust | High volume, strict timing or unusual rules |
| Fit for your own business rules | Low | Medium to high | High | Highest |
| Error handling | Built in | Built in, with dashboards | Designed per workflow | Designed per service |
| Who can change it | An admin | A Celigo-skilled admin | An ops-minded admin or a developer | A developer |
| Running cost | Subscription | Subscription that scales with flows | Low, or a server if self-hosted | Hosting plus maintenance |
Most businesses end up with a mix: a connector or Celigo for standard orders and stock, and a small custom or n8n flow for the one process that doesn’t fit.
What you get
- Integration blueprint
- Record ownership, field mappings, sync direction, timing and error rules for every flow, agreed before build starts.
- Production integration
- Deployed to your own accounts: your Celigo or n8n instance, or your cloud account for custom services.
- Error handling and alerts
- Retries, a replayable queue of failed records, and alerts by email or Slack when something needs a person.
- Reconciliation report
- Evidence that records match across systems after the backfill and again at go-live.
- Runbooks and handover
- How each flow works, how to replay a failure, how to rotate credentials, and a walkthrough with your team. You own the code, credentials and API apps.
How the project runs
Step 01
Paid discovery
We review your systems, data and current workarounds, and map each flow. Fixed fee, credited to the build if you go ahead.
You get: Integration blueprint and a fixed-price proposal
Step 02
Build
Flows are built in order of business value against sandboxes, with a demo of working syncs at each milestone.
You get: Working integration in a test environment
Step 03
Backfill and parallel run
History moves across, and the integration runs next to your current process until the numbers agree.
You get: Reconciliation report
Step 04
Go-live and handover
Production cutover on an agreed date, with a rollback plan written in advance.
You get: Live integration, runbooks and documentation
Step 05
Support (optional)
A monthly retainer covers monitoring, failed-record fixes and vendor API changes.
You get: Monthly summary of runs, failures and changes
Platforms and tools
- ERP and accounting
- NetSuite (SuiteScript, SuiteTalk REST, RESTlets, saved searches)
- QuickBooks Online API
- Commerce, payments and CRM
- Shopify Admin GraphQL API and webhooks
- Stripe API and webhooks
- HubSpot CRM API
- Integration platforms
- Celigo
- n8n
- Prebuilt connectors
- Custom services
- TypeScript
- Node.js
- Python
- PostgreSQL
- AWS
- Docker
- NetSuite
- QuickBooks
- Shopify
- Stripe
- HubSpot
- n8n
Product names and logos belong to their owners. Listing them doesn’t imply a partnership.
How you can work with us
Integrations have a clear scope once discovery is done, so most are fixed price. Small fixes to an existing integration can run hourly, and live integrations usually move to a support retainer.
Usual fit for this service
Fixed price
A defined integration, workflow or first release of an app.
Discovery produces a written plan with scope, deliverables and a fixed price. Changes to scope are quoted before they're built.
Hourly
Small changes, fixes, or work that's hard to scope until someone looks at it.
Time is logged against each task, so you can see where every hour went.
Monthly retainer
Integrations and automations that are live and need someone responsible for them.
Monitoring, fixes and small changes during business hours, Monday to Friday (PKT), with a monthly summary.
Dedicated developer
Ongoing product work where you want the same engineer every day.
One engineer works in your tools and stand-ups full time. You set the priorities.
Common questions
Something else? Ask an engineer.
Should we use a prebuilt connector, Celigo, n8n or custom code?
It depends on the flow, not the project. Prebuilt connectors suit standard flows at modest volume. Celigo suits NetSuite-centred businesses that want a managed platform with templates. n8n suits teams that want to see and adjust the logic themselves. Custom code suits unusual rules, high volume or strict timing. Discovery ends with a recommendation for each flow, and one of our engineers holds a Celigo certification.
How much does an ERP integration cost?
The price depends on the number of flows, how much history needs to move and how unusual your rules are. Paid discovery is credited to the project, and it ends with a fixed price.
How long does a NetSuite or QuickBooks integration take?
. The discovery blueprint includes a dated plan for your project.
Can you work with a heavily customised NetSuite account?
Yes. Discovery includes a review of your custom records, fields, scripts and workflows, so the integration works with your customisations instead of around them.
How do you prevent duplicate orders and missed syncs?
Every write carries an idempotency key or external ID, so a retried request updates the same record instead of creating a new one. Failed records go to a queue that can be replayed, and alerts fire when anything waits too long. We explain the mechanics in our post on duplicate orders.
Who owns the integration code, credentials and API apps?
You do. Code lives in your repository, credentials in your secrets manager or integration platform, and API apps are registered to your accounts. Handover includes documentation and runbooks.
Can you take over or extend an integration someone else built?
Yes. We start with a review of how it works today and what fails, fix what’s risky, then extend it. If it’s cheaper to replace a flow than repair it, we’ll show you why.
What happens when a vendor changes its API?
On a support retainer, we track deprecation notices for every API in your integration and schedule upgrades before the cut-off. Without a retainer, the runbooks tell your team where the version is set and what to test.
Map your integration with the engineer who’ll build it.
Tell us which systems are involved and what has to move between them. We’ll reply within one business day with questions, or a time for a call.
We reply within one business day (PKT, Monday to Friday).