It’s no surprise that software integration is a hot topic these days. Or that there’s a growing number of iPaaS (Integration Platform as a Service) solutions that help companies build integrations between all the different applications they use.
Businesses are using more and more unique applications as part of their day-to-day operations. That presents challenges like siloed data and disjointed workflows, creating a need to easily connect those applications.
What’s a bit more surprising is that traditional iPaaS solutions don’t work for one group that builds a lot — and I mean, a lot — of software integrations: B2B software companies. In many B2B verticals, the burden of building integrations falls to the companies who provide the software rather than the companies using the software. (You know the software company you work at is in one of those industries if your devs spend too much time working on integrations instead of building core product features.)
Unfortunately, B2B software companies face some additional complexities when providing integrations between their own software and other systems their customers use, complexities traditional iPaaS doesn’t address.
Some Background on iPaaS
We’ll dig into those complexities in a bit. First let’s take a quick look at what iPaaS is, and then come back around to why it doesn’t work for B2B software companies.
iPaaS stands for Integration Platform as a Service. An iPaaS is a set of tools that helps organizations develop and manage integrations between multiple software applications.
I’m not usually a fan of dropping buzzwords like “digital transformation” and the “explosion of SaaS,” but they’re real factors here. Many companies are now using tens or even hundreds of different software applications, and their IT environments have become increasingly complex. They have more data than ever before, but it’s spread across a variety of systems. They have best-of-breed software in place to solve all sorts of business needs, but processes become inefficient as employees jump between multiple applications to do their work.
Companies implement iPaaS in order to connect all of those applications. This lets them get better visibility into their data, improve employees’ workflows, and even automate some processes entirely.
They could, of course, build and maintain all of those integrations in-house. That would be a heavy IT burden, though, requiring developers to build API connectors and logic for numerous integrations, build and maintain infrastructure to run those integrations, and set up tools to manage and monitor them. An iPaaS allows them to instead consume a service that provides all of that functionality.
iPaaS systems vary widely from one to the next, and most iPaaS systems have a fairly broad set of features and capabilities. Core iPaaS functionality typically includes:
- A system for developing integrations (sometimes called automations or workflows)
- API connectors for popular SaaS applications
- Support for various data formats and standards
- Tools for data mapping and transformation
- Tools for integration monitoring and management
These features combine to reduce the overall effort of developing and managing software integrations. Many of them address not only application integration scenarios, but also data integration and even B2B ecosystem integration, enabling companies to automate processes with business partners and suppliers.
iPaaS systems serve customers in almost every industry. Some are geared toward small and midsize businesses and others toward larger enterprises. Most enable less technical business users, often called ad hoc integrators or citizen integrators, to build and manage integrations using low-code or no-code tools.
With such a variety of solutions catering to different types of companies and needs, more and more companies are adopting iPaaS. In their 2020 Magic Quadrant for Enterprise Integration Platform as a Service, Gartner estimated that iPaaS was a $2.5 billion market in 2019, up 48% from 2018, and will reach over $5.6 billion in revenue by 2024.
Why iPaaS Doesn’t Work for B2B Software Companies
Clearly, iPaaS has a lot to offer companies that need to integrate the various systems they use internally.
However, traditional iPaaS systems don’t work for B2B software companies because they have some unique attributes when it comes to integrations.
B2B software companies are typically:
- Building, deploying, and supporting integrations for their customers
- Integrating with niche software systems that vary widely from a technical perspective
- Dealing with a very diverse customer base with respect to the integrations they need and how they need them configured
These unique factors lead to some key gaps that leave B2B software companies unable to leverage traditional iPaaS systems. Let’s look at those gaps to understand why traditional iPaaS doesn’t work for them.
We’ll start with the most fundamental gap: B2B software companies are building, deploying, and supporting integrations for their customers — but traditional iPaaS systems simply don’t have the concept of customers.
As such, they provide no way to efficiently build and deploy integrations for multiple customers or to separate and securely manage multiple customers’ data. That includes sensitive data that passes through integrations and even customers’ credentials for third-party applications and services.
They also don’t handle B2B software companies’ frequent need to a build reusable integration workflow and deploy it to multiple customers. This is a very common situation. For example, you might need to build an integration between your own software and an ERP that many of your customers use, and then deploy that integration to tens or hundreds of customers using each customer’s own unique credentials, API endpoints, and so on. Traditional iPaaS systems don’t provide methods for building reusable integration workflows or managing multiple customers’ credentials and configurations.
They also don’t provide a way to effectively monitor and support integrations on a per-customer basis.
You occasionally see someone float the idea of implementing a separate instance of an iPaaS for each customer as a potential workaround, but the cost, logistical complexity, and duplication of work make that plan a non-starter.
Another gap is that the low-code or no-code approach of many iPaaS systems doesn’t work for B2B software companies, because they often need to develop complex integrations connecting niche systems that vary widely technically.
For companies integrating internal systems, part of the allure of many iPaaS systems is that they are low-code or even no-code platforms.
This works quite well business users in areas like marketing and operations creating straightforward workflow automations for their own use: When a new row is added to a Google Sheets spreadsheet, make an invoice in QuickBooks Online. When a lead is created in Salesforce, send a Slack message to notify the team. And so on.
It works far less well for B2B software companies. Unfortunately, the simplicity of low-code iPaaS usually comes at the cost of the power and flexibility needed to build many of the integrations their customers need.
Many B2B software companies provide software to customers in niche vertical markets — think museum management software, equipment rental software, golf course software, and so on.
This means that one of their most common integration needs is to build integrations to the other niche vertical systems their customers use. Those systems tend to vary widely technically, ranging from SaaS systems with modern APIs to legacy on-prem systems using all sorts of different protocols and data formats. Unsurprisingly, iPaaS systems don’t include connectors to those systems.
B2B software companies, by virtue of being software companies, have a team of developers at their disposal who could extend pre-built connectors, build additional connectors to niche-specific systems, write code to handle complex logic, and so on. However, most iPaaS systems aren’t designed with developers in mind and don’t provide dev-friendly tools for extending the platform beyond its out-of-the-box functionality.
As a B2B software company, it’s critical to be able to provide any integration customers need. An integration platform that doesn’t handle building more complex or vertical-specific integrations isn’t a viable solution.
This next gap is this: traditional iPaaS doesn’t fit well into B2B software teams’ existing infrastructure and processes.
At B2B software companies, integrations are just one part of a larger software project. Every software team has an entire ecosystem of tools and processes that define the way they build, deploy, and support software. That includes their source control system, CI/CD pipeline, testing and deployment methods, logging systems, and incident response tools, just to name a few.
For a new tool to work in the real world of a software company — whether it’s an integration platform or anything else — the team needs to be able to fit it in smoothly with the tools and processes they already use.
Traditional iPaaS systems weren’t designed for building integrations as part of a larger software project and simply don’t provide ways for dev and DevOps teams to fit them into their broader ecosystem.
Finally, traditional iPaaS solutions don’t offer an embedded integration experience that B2B software companies can provide to customers as part of their product offering.
Most B2B software companies need to provide customers with self-service integration tools so that they can keep tabs on their own integrations, check status and logs, and in many cases even build or enable integrations for themselves.
That usually comes in the form of an integration portal or marketplace embedded right in the main application. It’s important that it be embedded so that customers perceive all of it — the integrations themselves and the tools surrounding them — as additional value provided by the core product. Additionally, it lets the software company stays in control of the customer relationship rather than introducing another vendor into the situation.
An embedded customer integration experience has significant benefits for the software company. Not only does it improve customer satisfaction through a better integration experience, it also reduces the software company’s support workload because customers can answer many of their own questions. And by facilitating the discovery and usage of more integrations, it makes products stickier and reduces customer churn.
Because traditional iPaaS systems aren’t designed for building integrations for customers, they don’t include a way to provide this type of an embeddable integration experience.
If B2B software companies can’t use traditional iPaaS, what then?
Given that they can’t leverage traditional iPaaS systems, most B2B software companies still do a lot of integration work from scratch or use home-grown tools, which are a major effort to build and maintain in their own right. For most B2B software companies, integration remains a challenging and time-consuming process. This slows down SaaS startups’ time to market and bogs down product roadmaps for more established software providers.
The reality is, B2B software companies need a non-traditional integration platform — one designed specifically to address the additional complexities with providing integrations to customers.
That’s where Prismatic comes into play. My team and I experienced all of these integration challenges firsthand at our own B2B software company and built Prismatic for the express purpose of solving them for other B2B software teams.
Prismatic is the first integration platform built from the ground up to meet the specific needs of B2B software companies. It provides the key benefits of a traditional iPaaS while addressing the additional complexities head on, so B2B software companies can spend less time on integrations and more on core product innovation. Contact us to learn more.
Originally published at https://prismatic.io.