Case Study: Rescuing a Shopify and NetSuite Celigo Implementation
Client Overview
The client is an ecommerce company using Shopify and NetSuite. It needed an integration that could move data between the two systems, match records consistently, and give the team a way to audit orders.
The Challenge: Months of Work and Unresolved Issues
An ecommerce company hired an implementation partner to connect Shopify and NetSuite using Celigo. The project took months and was riddled with issues. The company came to SixLakes Consulting for help rescuing the implementation.
The rescue involved more than fixing individual errors. We corrected field mappings, made IDs and record lookups more consistent, and built a custom dashboard to audit orders. We also added a backup batch process to automatically resolve issues left by the real-time integration.
The Celigo integration app had limits for this project's needs. We reimplemented the integration with a custom solution so the design could better support the business.
Our Review of the Existing Implementation
We conducted a review of the existing integration. Our analysis focused on how data was mapped, how records were identified, and how the process handled issues after the real-time flow ran.
These parts need to work together. A field mapping tells the integration where a value belongs. An ID helps identify the record. A lookup helps find the matching record in the other system. Fixing one part leaves gaps if the others remain inconsistent.
Correcting Mappings and Record Lookups
We fixed the mapping issues between Shopify and NetSuite. We also implemented more consistent IDs and record lookups. That gave the custom solution a clearer way to match records across the two systems.
- Corrected how source values mapped to destination fields.
- Made record IDs more consistent across the integration.
- Improved the lookups used to find matching records.
These changes addressed the foundation of the integration. Before a process can recover reliably, it needs to know which record it is working with and where the data should go.
Why the Project Needed a Custom Solution
For this company, the existing Celigo integration app did not meet all of the project's needs. Continuing with the same setup would leave those limits in place. We reimplemented the integration with a custom solution.
This was a decision about the fit for this project. It does not mean every Shopify and NetSuite integration needs a custom build. The right choice depends on the business rules, the required record lookups, and how the team needs to handle failures.
If your team faces that choice, our guide on when to rebuild a Celigo flow can help frame the review. Start with what the process needs to do, then check whether the current design supports it.
What We Changed
The rescue addressed both the data moving between systems and the way the team could check and recover that work.
| Area | Change made | Purpose |
|---|---|---|
| Field mappings | Fixed mapping issues | Send source values to the intended destination fields |
| Record matching | Implemented more consistent IDs and lookups | Find the matching record more consistently |
| Order review | Built a custom order audit dashboard | Give the team a place to audit orders |
| Recovery | Added a backup batch process | Recover from real-time issues involving source rate limits, system outages, and difficult retries |
| Integration design | Reimplemented with a custom solution | Address the integration app's limits for this project |
The dashboard and batch process served different purposes. The dashboard supported review. The batch process provided a second path for resolving issues that the real-time flow left behind.
Adding an Order Audit Dashboard
The company needed a way to audit orders across the integration. We built a custom dashboard for that work.
An order audit asks a business question: did the order reach the expected state? That is different from simply checking whether a flow ran. Giving the team a place to review orders made auditing part of the solution itself.
The dashboard complemented the mapping and lookup fixes. Those fixes improved how records were handled. The dashboard gave the team a way to review the orders the integration was handling.
Giving Real-Time Integration a Backup
The real-time integration faced three specific issues that made recovery harder:
- Source-system rate limits. Limits on requests could prevent the integration from completing work when it needed to.
- System outages. When a connected system was unavailable, the real-time process could not complete the exchange.
- Difficult retries. Failed real-time attempts were not easy to retry, leaving issues that needed another recovery path.
We added a backup process that ran in batches to automatically resolve issues left by the real-time integration. It provided a separate recovery path when the immediate exchange could not finish.
This gave the solution two paths: the real-time integration for the immediate work, and the batch process for recovery. The backup addressed issues left by the first path rather than making the real-time process responsible for every recovery step.
A backup process still needs clear rules. When designing a similar solution, define which issues it can resolve, how it finds the right record, and what needs human review. A batch process should not be treated as a promise that every possible error will fix itself.
The Five Parts of This Rescue
The changes below show how the work fitted together, from the original setup to the added recovery process.
Results: A Custom Integration With Audit and Recovery Tools
The rescue replaced the troubled implementation with a custom solution. It addressed the mapping problems and made record matching more consistent. The company also gained an order audit dashboard and automated batch recovery.
Those are concrete changes to how the integration works and how the team can oversee it. The project went beyond treating each error as a separate problem. It addressed data handling, visibility, and recovery together.
What Other Ecommerce Teams Can Learn
If a Shopify and NetSuite project has dragged on for months, take a fresh look at the design as well as the open issues. Useful questions include:
- Do the mappings reflect the values the business expects?
- Are IDs and lookups consistent across the process?
- Can the team audit orders after they move between systems?
- What happens when the real-time integration leaves an issue unresolved?
- Does the integration app fit the business needs, or is a custom solution needed?
In this project, the answer was a custom implementation with better record handling, an audit dashboard, and a batch backup. Another project may need a smaller set of changes. The review should establish that before more work begins.
SixLakes helps teams assess troubled implementations and plan a practical recovery. Bring your current setup and examples of the issues to a Celigo integration review. We can help identify what needs to change.