Using Prismatic to Save Time Building Multiple Similar Integrations
Prismatic makes it easier for B2B software companies to provide the integrations their customers need.
Today, we'll look at a type of integration scenario that teams commonly face – needing to quickly build, deploy, and support multiple similar integrations – and how it can be addressed using Prismatic.
Meet Progix and their ERP integrations
I'll begin by introducing Progix Software. Progix works in the aerospace vertical and provides project management software for companies that manufacture and launch rockets. As you've likely guessed, Progix isn't a real company, but it does represent multiple real companies we've worked with combined into one. (With rockets!)
Over the course of a few months, the Progix team fielded requests for ERP integrations from numerous customers and prospects. Specifically, whenever a rocket launch occurred, the customers wanted Progix to pass the amount and type of fuel used to their ERP system and deduct it from inventory.
As the Progix team dug in with a handful of customers on the ERP integration requests, they identified three challenges:
- They needed to build multiple integrations. It turned out the customers requesting ERP integrations actually used four different ERPs, so they were going to have to build four integrations.
- They needed to deploy to multiple customers with different credentials, endpoints, and versions. Over thirty customers had requested these integrations, and up to a hundred more would eventually need them. That was going to mean spending a lot of time on infrastructure and configuration.
- They needed an easy way for the support team to troubleshoot when a third-party system caused a problem. If something were to go wrong with an integration – no matter whose fault – the support team would need to be able to dig in quickly to troubleshoot, ideally without involving the engineering team.
The Progix team had built other integrations for their customers previously, and every one of them was difficult and time-consuming, both from an engineering perspective and for other teams such as onboarding and support.
Most importantly, their current integration methods took a lot of development capacity away from core product work. They started looking for an easier solution.
The decision to use Prismatic
After some research, the Progix team decided to build the ERP integrations using the Prismatic integration platform. Prismatic was designed specifically for B2B software companies, and because it offered tools for every phase of the integration build-deploy-support process, it addressed each of their challenges:
- Prismatic's integration designer allowed assembling integrations using pre-built components and dropping in their own code snippets or custom components when needed. This would let them write far less integration boilerplate code.
- Between the customer deployment management functionality and the fact that they wouldn't have to build or manage any infrastructure to run the integrations, they'd be able to spend less time on deployment.
- Prismatic included logging, monitoring, and alerting capabilities, so the support team could get notified if something went wrong with an integration and start troubleshooting without engineering involvement.
Go time: completing the first ERP integration
Of the four ERPs Progix needed to integrate with, one was a general ERP, one was a niche ERP for the aerospace vertical, and two others were older systems that didn't have modern APIs. They decided to start by building the integration to AcmeERP, the ERP used most commonly by their customers. It was a vertical-specific ERP for rocket companies with a modern REST API that used OAuth 2.0 credentials for authorization.
Let's take a look at how Progix used the Prismatic platform to complete their AcmeERP integration.
Building the AcmeERP integration
Alex, a Progix developer, used Prismatic's graphical integration designer to assemble the integration using a series of components. Here's the integration he created:
Prismatic integrations are self-documenting, so Alex's team members could skim through the designer to understand what he'd built. Let's take a quick look at each step:
- First, he specified a webhook trigger. When a rocket launches, Progix triggers a webhook with a JSON payload containing the type and amount of rocket fuel that was used.
- Next, he added a custom component that he'd built using Prismatic's custom component library. It examines the webhook payload and verifies that the request came from a Progix system by checking that the
X-Progix-Signatureheader is valid.
- Next, he added a built-in component, the Change Data Format component. AcmeERP only accepts XML, so this component converts the fuel data from JSON to XML.
- Finally, he added another built-in component, the HTTP component, to send the data to AcmeERP. The HTTP component makes a POST request to the AcmeERP endpoint with the XML payload.
Using several built-in components saved Alex time by abstracting a lot of complexity so that he could write less boilerplate. Most notably, he didn't have to write a single line of code to handle the OAuth 2.0 flow for authorization against AcmeERP. Instead of writing code to deal with authorization codes and access tokens and refresh tokens and so on, he simply specified OAuth 2.0 as the credential type on his HTTP component, and Prismatic handled the rest.
Meanwhile, using a custom component and a code component gave him the flexibility to build exactly the functionality that was needed.
Testing and iterating to get it right
Alex used Prismatic's built-in testing tools to test the integration as he assembled it, which allowed him to iterate quickly. He pointed the testing tool at AcmeERP's sandbox API. As he added each component to the integration, the testing tool ran his integration and showed the outputs of each step, right on the same screen where he was already working.
Instead of having to wait through recompiling and redeploying, he had a fast feedback loop – seconds rather than minutes or hours – for verifying that each step was working as expected. He made a few tweaks to his components as he went and was able to iterate very quickly.
Deploying the AcmeERP integration to customers
Next, the Progix team needed to deploy the AcmeERP integration to numerous customers, each with unique configurations and credentials. Prismatic treats integrations as reusable objects that can be deployed to multiple customers using instances. This made it easy for the Progix team to manage deployment cleanly.
Jordan, a Progix onboarding specialist, easily configured a customer-specific instance of the AcmeERP integration for each customer who needed it. Prismatic automatically generated the instance's unique Prismatic webhook endpoint.
For each instance, Jordan entered the customer's unique AcmeERP endpoint and used Prismatic to send each customer a link where they could enter their OAuth 2.0 credentials for AcmeERP, which meant that no one was even tempted to send them via email, and removed Progix from the credential flow completely.
From there, it took just a few more clicks to test and deploy the customer-specific instance.
Setting up monitoring and alerting
Progix wanted two parties to be alerted if an instance of the integration failed to run: the customer's own system administrator and the Progix support team. This would keep customers in the loop and let the support team respond to problems quickly. Jordan set up a Prismatic alert monitor to notify both parties if the instance failed to run to completion.
The remaining three ERP integrations
When it was time to build the other three ERP integrations, Progix developers were able to reuse the custom component Alex had built to verify Progix payload headers.
The main differences between the ERP integrations were the data format and mechanism by which each integration uploaded data to the other ERPs. One ERP required data to be in CSV format and uploaded to an SFTP server, and another required YAML-formatted files to be uploaded to an AWS S3 bucket. Prismatic handled each of those use cases out of the box.
Using an integration platform freed up time for core product
By using Prismatic, the Progix team was able to build four ERP integrations and deploy over thirty unique customer instances with far less time and hassle compared to previous integration projects. This freed up significant engineering time to invest in their core product.
Since the completion of the initial ERP integration project, Progix has continued to realize time savings. Prismatic has empowered non-development team members with the tools they needed to deploy additional customer instances and troubleshoot the few problems that have arisen – usually caused by a problem with a third-party system – with little to no engineering involvement. As a result, the Progix development team has been able to stay focused on delivering core product features.
To learn more about how your team can use Prismatic to save time building, deploying, and supporting your integrations, check out our docs or contact us.
Next up on the blog, we'll do a deeper technical dive into Progix's AcmeERP integration. We'll look at how code components and custom components give developers the ability to incorporate custom code alongside built-in components to quickly create specialized integrations.
Prismatic is the integration platform for B2B software companies. It's the quickest way to build integrations to the other apps your customers use and to add a native integration marketplace to your product. A complete embedded iPaaS solution that empowers your whole organization, Prismatic encompasses an intuitive integration designer, embedded integration marketplace, integration deployment and support, and a purpose-built cloud infrastructure. Prismatic was built in a way developers love and provides the tools to make it perfectly fit the way you build software.
Get the latest from Prismatic
Subscribe to receive updates, product news, blog posts, and more.