Here's a scenario from our archive of prospect and customer conversations:
We created an integration with our app and Salesforce. Several customers wanted the integration when we told them about it, but each wanted slightly different functionality. The bottom line is that we now have 25 versions of the same integration in production. Despite doing a lot of extra work to get to this point, our integration team and our customers aren't happy.
Unfortunately, this is all too common. It starts with a lovely idea: "Let's make all of our customers happy!" but ends with everyone wondering if there's a way out of the mess that's been created.
So, what is the root problem here? Simply put, the root problem is the absence of a scalable, standardized development framework.
The solution? We'll get to that. But first, what other issues are likely to accompany this scenario?
Related issues
These are not the only additional issues that might arise in this scenario, but they are some of the most concerning.
Onboarding slows to incorporate customer-specific requirements
One of the benefits of having an off-the-shelf integration ready to go at onboarding is that the time cost of adding that integration into the process is relatively small. However, in this scenario, where each customer is receiving a custom integration, the opposite is true.
If the integration team can't build the integration until talking to the customer, that will delay the start of the integration development. Customers will wait for the integration as devs gather each customer's unique requirements and then develop, test, and deploy – with as many iterations as needed to get things exactly right.
Meanwhile, the customer has probably completed onboarding with the product but doesn't feel the process is complete since the custom integration isn't yet ready. They are also investing more effort in onboarding than initially anticipated for a SaaS product.
Engineering and support struggle with training and knowledge gaps
The more versions of an app (or an integration) there are in production, the harder it is to ensure that everyone working on those integrations is kept up to date with the details. With 25 versions of an integration, someone may be trying to update a knowledge base. But, as more integrations are built and the existing ones are modified, the odds of this knowledge base remaining correctly updated are poor.
As a result, there's no single point of truth for training new devs and support personnel. Because of that, everyone's working on integration version X with the understanding they have from previously working on integration version Y, and so they make mistakes out of ignorance.
Further, because of the many versions, it's more likely that support is going to have difficulty troubleshooting issues. This leads to either a time-consuming investigation or escalation to engineering for just about every issue. In either case, the process is much less efficient and consistent that it ought to be.
Version control, testing, and deployment processes are non-optimal
Version control is critical for modern software development. However, creating so many custom variants of an integration means that the team either ends up with several repositories (one for each customer) or a central repository with extensive branching and tagging to differentiate the code that applies to each customer. Along with this, configuration management brings its own complexity as the team tracks things like auth, connection parameters, and data mapping for each customer.
Maintaining robust testing templates and procedures also becomes more challenging. The team must use automated testing procedures to test all these different versions. At the same time, the tests must be tailored to each integration, significantly increasing the time it takes to keep everything up to date.
For deployments, the team will either need to build individual pipelines for each integration or create a very complex single pipeline for everything. And, since all these integration versions for different customers are being updated with different frequencies, the number of deployments will increase. At the same time, performing rollbacks can be pretty exciting as the team will often need to dig into the code to determine if an error in one integration version impacts other versions.
Standardization benefits are elusive
As new versions are created for each customer, the ideal of a standardized integration is left further behind. No matter how much the team may want to keep things consistent, the reality is otherwise.
In this scenario, maintenance complexity is significantly increased. Updates, bug fixes, and even security patches must be reviewed for applicability to each of the integrations. And since each integration needs individual attention, the team risks increased errors and oversights.
One of the benefits of modern SaaS apps is the consistent user experience. And the best apps keep this consistent UX through the integrations. However, with so many different versions of an integration, it's nearly impossible to ensure that each customer is receiving a first-class UX. Custom integrations, particularly those built reactively (as seen here), will vary significantly in performance and stability, leading to an inconsistent customer experience.
Don't stay where you are
If this scenario and its related issues match how things are going for your integrations, we have some good news: you don't need to stay where you are.
Remember this scenario's underlying problem? "The absence of a scalable, standardized development framework."
To address this, we bring you Prismatic – a scalable, standardized development framework (aka embedded iPaaS). Here's how it helps.
Onboarding is streamlined
Prismatic comes with pre-built connectors for many standard apps, provides a low-code environment for non-devs to build integrations, but also supports devs building integrations in code – all of which lead to faster development times when new integrations must be included with customer onboarding. And teams can iterate and prototype faster, leading to quickly improved integrations if issues arise during onboarding.
Devs, in addition to building full integrations in code, can also create reusable components, such as a custom connector with their product's API. Our platform provides customers with the ability to configure, activate, and even support integrations themselves, ensuring that they are not dependent on support for everything in the onboarding process.
Engineering and support enjoy needed consistency
Prismatic is a single platform for building, deploying, and managing all your customer integrations. As a result, devs and non-devs alike know where to get the latest integrations, check out configs, run tests, or do anything else an integration needs.
The platform provides a full range of tools and workflows necessary to create and support integrations, making training teams on their portion of the integration process more manageable.
And, since our platform provides the necessary infrastructure for the integrations, everything from compute resources to auth to data logging and security is abstracted, allowing your team to focus on the unique requirements of the integration proper (and a whole lot less code to version and maintain).
Version control, testing, and deployment are familiar
Prismatic allows you to manage your integration code with the version control tools you use for your core product. Rollbacks are not nearly so dangerous since returning to a prior stable integration version is straightforward.
In addition to testing tools provided by the low-code designer, your devs can use their favorite automated testing tools to work with integrations in code.
You can also incorporate your integrations into your standard CI/CD pipeline, allowing you to extend your standard release processes to your integrations and set up automated deployments to move from dev to staging and production.
Standardization benefits are obvious
Prismatic drives standardization starting with reusable pre-built and custom connectors, templates, config wizards, and even integration flows.
When it comes to maintenance, our platform provides a single place to manage and monitor all the integrations. This allows us to identify issues, apply updates and fixes and ensure consistent performance across the full range of deployed integrations.
And, perhaps most importantly, our platform enables a consistent first-class UX within a single integration as deployed to many customers and across every customer integration you have. For example, the platform enables standard error messages and feedback mechanisms for all integrations, ensuring customers are never left wondering what's happening.
What next?
Prismatic allows you to create a productized integration with a robust configuration and then deploy it to as many customers as you need, all without the headache that comes with building, deploying, and managing code for N slightly different versions of a single integration.
Request a quote, and let us show you how moving from a one-off, customized approach to productized integrations can lead you to a largely pain-free, scalable integration strategy that will serve you and your customers for years to come.
