Advanced Cin7 Integrations with the GrowthPath stack

The GrowthPath Application Server is a dedicated server with software developed to allow GrowthPath's advanced integrations. For specific information about "dedicated", see below. (The documentation and code base may refer to Dear for historical reasons)

The Application Server is a stack of software which makes it fast and easy for GrowthPath to solve complicated integration problems.

The elements of the stack are

• A robust, battle-tested cache of Cin7 Core's data, including the ability to bring together all your deployments of Cin7 Core, even in multiple currencies
• A library of Cin7 Core automation code for ordering, shipping and production steps, which is also battle-tested. With this code, we can develop highly advanced automations and integrations
• A library of connectors to a growing range of cloud software: Zoho Analytics, Zoho CRM, Capsule, Shopify, Starshipit, Xero, ... These include advanced data syncs.
• A growing library of EDI X12 messages (currently ASN, PO, PO ACK, Inventory, Invoice)
• We have a library for advanced, custom 3PL integrations which can split orders amount different 3PLs for optimal fulfilment, and locations and handle all kinds of specific needs

How does it compare to N8N or Zapier?

Code built on the GrowthPath Application Server can use the robust cache, which is not only much faster, but which allows complicated queries. For example, we can find all orders for the past 12 months which involve a particular SKU sold from a particular location to a certain customer. The Cin7 Core API can not do such queries, so a naive user of the endpoints must load every order and then iterate over them. The GrowthPath Application Server can send these advanced json queries directly to the backing database and retrieve the answer quickly.

The code library itself has much business logic embedded in it, based on years of accumulated work. For instance, we have libraries that will quickly allow a change of order header location by undoing the order, change the header, and then reauthorising it, include reauthorising any invoices and payments, while at the same time having validation checks, and distributed locking to make sure nothing else is working on the order. We also maintain records of concepts such as soft and hard allocations to make sure fulfilments will succeed. The API does not expose this directly, it is another example of the added value logic of the application server.

Also, the code is under version control and tests, and is professionally engineered by experts who deeply understand the system.

Low code tools are fast and empowering, although AI assistants are even more effective in the hands of experience developers.

Like spreadhseets before them, they are incredible tools for getting things done quickly and for user who previously had no real way of accessing automation.

They run into problems as requirements become more complex and as they are used by users who don't have a solid foundation in the skills of enterprise IT, such as security, source control, testing and performance questions. The challenge is knowing when the line is crossed.

 

 

Example of the backend: examining a cached Sale object

 

 

Based on surveying the market and listening to the customers we acquire,  this technology stack is well ahead of any competitor. It is the result of constant work since 2012 and a growing number of deployments. We tend to get clients with scale and requirements which can't be met elsewhere, which is further testing and developing our technology.

What does the Cin7 Core GrowthPath Application Server mean for clients?

Most of GrowthPath's integrations involve Cin7 Core. As a cloud ERP, Cin7 Core is the transactional heart of your business system. Our integrations move data from Cin7 Core to and from other platforms (such as Zoho Analytics, Power BI, Loop Returns, Shopify, Zoho CRM, Xero, Starshipit, our 3PL module), and they perform automations and updates in Cin7 Core.

Our integrations also often do automation in Cin7 Core, such as order routing, processing assembly orders based on a configured BOM, shipping orders after the 3PL confirms dispatch, or rewriting payment references for better B2C payment matching to bank feeds.

Some of our clients are very high volume users. Traditionally, an integration calls the Dear (Cin7 Core) API each time it needs information. This does not scale very well, since the Dear API has limits. Also, several integrations may be retrieving the same information again and again, which is a waste (and it is slow). Instead, the GrowthPath Application Server has a cache which has an up-to-date copy of Cin7 Core's data. Our integrations use the cache, which is much faster. As well, locally cached data can be processed with much more sophisticated queries. Also, some larger clients use multiple instances of Cin7 Core. The cache means we can bring this data together.

Many simple integrations don't use caching because it is hard to get right. Because GrowthPath uses the same cache for many different integrations and automations, we have been able to invest and develop our cache to the point where it is a very significant technical advantage. GrowthPath's cache is widely deployed and is very robust after years of production use. It has developed many advanced features, including the ability to share its workload over multiple Dear API connections for very high volume sites that are not yet ready to move to one of Dear's dedicated server options. It contains many tweaks and optimisations.

The cache is stored in a high-performance database that offers traditional SQL and more modern JSON data processing. The Cin7 Core cache is a collection of JSON records that are straight from Cin7 Core.

Our code library has many building-blocks based on the cache (for reading data) and in combining the low-level Dear API into business workflows. For example, we have code which will take an authorised  Simple Sale, and will split the order into multiple fulfilments across different locations based on logic that determines the fastest way to get all lines delivered bearing in mind costs, and then feed these fulfilments to one or more 3PLs. When the 3PL confirms manifesting, we complete the shipment in Cin7 Core and post the tracking information back to the online portal.  This complex code path is handled by building blocks we already have. Likewise, we have built a custom configurator that will read order line comments for product options, produce a configured custom BOM, and pick and complete the order assembly with a batch code based on the customer's order.

Our Analytics connector uses the cache to perform complex combinations of Dear data to enable powerful reports. It also has integrity checking to make sure the Analytics data is accurate: web-based APIs are not as reliable as traditional high-speed integrations running on the same server.

Secure, robust dedicated servers

The fleet of GrowthPath application servers is hosted in Amazon Web Services managed Kubernetes service, in a US zone; US zones perform the best with cloud APIs.

The database service uses the AWS RDS service (postgresql).

Each client Application Server is a dedicated namespace with dedicated CPU resources according to their level of service. Each client has a distinct database. There is no co-tenanting of data.

The code-base follows modern standards. It uses git, with a private repository on github, and automated deployments; typically a new deployment is ready in about 80 seconds from deployment, and there is no downtime during updates.

The software stack uses open-source technologies, most importantly Python, Postgresql, kubernetes, Django and the broader linux stack on which it runs. For sustainability, GrowthPath contributes financially to these, as well as contributing code. The development environment is secured with best practices, and is also based on Linux.