Integrations are essential to the value proposition for B2B software products. Business customers expect modern software to provide seamless, out-of-the-box connectivity to the rest of their tech stack.
As a result, today's software companies face a huge challenge. Along with their apps, these companies must deliver dozens – sometimes hundreds – of integrations for their customers' other apps and services. Often, these integrations are table stakes for getting to market, winning deals, and retaining customers.
This leads to questions for product leaders. How do you quickly deliver the integrations your prospects and customers need? How do you maintain and support them? As your customer base and integration demands grow, how do you do this at scale? Can you do it without using too many dev resources and neglecting your core product?
We've compiled this guide for B2B SaaS teams seeking a proven, scalable strategy for providing native integrations to their customers. We'll outline current integration opportunities and challenges and see why teams address them with embedded iPaaS.
An embedded integration platform, or embedded iPaaS, is a set of tools that enables a software company to quickly build reusable, configurable integrations and deliver them to its customers as a seamless part of its app.
It's called embedded because it has an integration marketplace that SaaS teams can white-label and embed in their product to create a self-activated, in-app integration experience for end users. (For this reason, you might also see this type of solution referred to as a white-label iPaaS.)
An embedded iPaaS is an end-to-end platform with everything SaaS companies need to build productized integrations, deploy them to customers or enable self-activation, run them in production, and provide support.
✓ A low-code integration designer that empowers non-developers to build productized integration workflows that can be configured and deployed to multiple customers.
✓ A library of built-in components that reduces the effort of building native integrations by providing connectivity to many common SaaS apps and standard integration logic functions without the need to write code.
✓ An integration marketplace that teams can white-label and embed in their product to provide a self-activated, in-app integration experience for end users.
✓ Integration deployment and support tools that enable customer-facing teams to configure, deploy, monitor, and troubleshoot customers' integrations without dev involvement.
✓ A cloud infrastructure that runs integrations and handles scalability, security, and compliance concerns.
To understand embedded iPaaS, let's first look at traditional iPaaS.
The term iPaaS stands for Integration Platform as a Service. The majority of iPaaS solutions available today are traditional iPaaS. These platforms help companies connect the SaaS apps in their tech stack and automate their internal processes.
There are many traditional iPaaS solutions on the market. Well-known platforms such as MuleSoft, Boomi, and even Zapier fall into this category.
Traditional iPaaS solutions are general-purpose platforms businesses use to create integrations for internal use. Embedded iPaaS solutions, by comparison, are purpose-built SaaS integration platforms software companies use to create native integrations for their customers.
Any B2B software company that needs integrations for its customers can use an embedded iPaaS. Embedded iPaaS solutions are used by startups, scaleups, and enterprises. SaaS companies, legacy or on-premise software providers – companies in almost every software market – can benefit from embedded iPaaS.
As noted earlier, integrations are table stakes in many markets – a non-negotiable requirement for building a product, closing sales, onboarding customers, and retaining them.
Several major trends are driving customers' expectations for more and better integrations, making integration delivery a critical part of B2B SaaS companies' strategies.
Here are those trends:
The proliferation and specialization of SaaS make connectivity essential. As companies regularly add new apps to run their businesses, it's even more important to buyers that each app serves its core function and fits into the company's larger tech ecosystem. Today's business customers expect any new software they purchase to connect to the other apps they use.
The pace of automation is accelerating. Businesses are automating processes and workflows to cut costs and boost productivity, increasing integration demand.
Integration expectations have come down-market. Smaller companies that don't have the IT resources to build those native integrations still expect them.
Business users expect less IT involvement with their apps. Users think they should be able to set up and operate their apps without relying on IT. This thinking also extends to integrations.
Beyond simply building the integrations that prospects and customers require, product leaders who create a strong integration capability can use it as a competitive advantage.
By using native integrations strategically, you can:
Increase product value. Integrations can extend your product, sometimes in outsized ways. For example, a project-tracking app that integrates with its users' calendars and messaging systems provides much more value to its users than one that does not.
Make your product the center of your customers’ ecosystem. When your product is the software integrating your customers' business apps, driving their data flows, and automating their processes, it becomes the hub of their ecosystems.
Increase product stickiness and reduce churn. Integrations can provide a strong moat, making your product hard to replace. Businesses don't want to take a step backward in automation and connectivity. If your product is deeply integrated, replacing it requires your customer to find another product that provides the same integrations.
Be strategic about what not to build. When the market asks for a feature with heavy R&D effort or one that doesn't fit your roadmap, choose not to build that feature. Instead, integrate with an app that provides it. This allows you to meet customer and prospect needs while focusing on what your app does best.
Historically, software companies have taken various approaches to customer integrations. Most likely, you have experimented with one or more of those approaches and have experienced some of the pain points for yourself.
Let's briefly review those approaches:
Put the integration responsibility on the customer. While placing the burden on customers to build their integrations may seem easy, this is a non-starter in many markets. If you can't provide the integrations your prospects need, a competitor in line behind you will.
Use a third party to build integrations. Involving a third party to provide integration services to your customers does reduce work for your team.
However, there are drawbacks:
- You give up revenue.
- You give up control over integration quality.
- You add a third party into your customer relationship.
- Customers in many markets won't accept it.
Use a traditional iPaaS and build around it. Some SaaS teams find creative ways to use traditional iPaaS to offer integrations to their customers.
As noted above, iPaaS solutions are made for internal integrations. They offer low-code integration designers and large SaaS connector libraries that make it easy to build one-off integrations. But providing customer integrations adds complexity that a traditional iPaaS does not address:
- Traditional iPaaS doesn't have the concept of customers or customer-specific config. Therefore, it does not offer a way to build reusable integrations that are deployable to multiple customers. Teams that use traditional iPaaS for customer integrations must deploy an instance of the iPaaS and/or rebuild similar integrations for each customer.
- These solutions rely heavily on a no-developer, low-code mindset, leaving teams stuck when building a complex integration or connecting an unsupported app.
- You can't easily incorporate a traditional iPaaS into software teams' existing systems. As a result, you end up with integration tools and processes separated from the rest of your dev environment.
- Traditional iPaaS can't deliver integrations with a native, in-app experience.
Build integrations and integration tooling in-house. Instead of using embedded iPaaS, it is common for some SaaS companies to build integrations in-house. You get the strategic benefits of integrations, keep the revenue, and control the quality of the integration experience for your customers.
But most companies find that building integrations in-house scales poorly and has other serious drawbacks:
- Building integrations and tooling in-house requires a dev effort that often distracts from core product work.
- Teams typically accrue a long backlog of integrations, slowing sales and onboarding.
- Getting integration infra right is hard, especially with security and scalability concerns.
- Your dev team spends time on things irrelevant to your app domain, like integration logging.
- Building the tooling for non-devs to deploy and support customer integrations is too time-consuming and expensive to do right. As a result, most teams don't do it at all, putting integration deployment and support on your devs.
Having worked with many software teams who tried to deliver integrations with these approaches, we've found a few common indicators for those who would benefit from an embedded iPaaS.
Here are the indicators, grouped by your company's level of product maturity:
If you’re a startup, or a new division or product line in an established company:
- Your prospects and customers frequently ask for more integrations.
- Your competitors have integrations you don't offer yet, and you need to catch up.
- Your developers spend time on integrations instead of your core product.
- Your developers spend more time than planned on integration infrastructure and tooling to deploy integrations, monitor them, and introspect when something goes wrong.
- Integrations are slowing down your overall pace and time-to-market.
- You have a small dev team and lack expertise with integration patterns and best practices.
- You or your customers have concerns about your integrations' reliability, scalability, security, or compliance.
- You're not sure your current strategy will scale well as you grow.
If you are a scaleup or enterprise company:
- You've already built many integrations but have an expanding backlog.
- Missing integrations are causing friction in sales and implementation. You're losing deals and delaying customer onboarding since you can't quickly deliver new integrations.
- You can't innovate on your core product as rapidly as you once did. Integrations absorb too much of your R&D.
- You've built up integration tech debt that makes internal gains difficult.
- You have reliability and scalability problems with your current integrations.
- Your dev team spends too much time on integration maintenance and support.
- You're delivering integrations as services or "bolt-ons" rather than as a first-class part of your product. Integration adoption is low since your customers can't find or self-activate existing integrations.
Given the value of customer integrations and the challenges with common approaches to delivering them, many B2B software companies find themselves looking for a better solution.
Embedded iPaaS evolved to give B2B software companies a more efficient, cost-effective, and scalable strategy for customer integrations.
Here are six good reasons to adopt an embedded iPaaS:
Building integrations and integration tooling in-house takes a lot of dev time and resources. Using an embedded iPaaS greatly reduces that burden.
An embedded iPaaS has a low-code integration designer and a library of pre-built SaaS API connectors and logic components. These let non-developers build integrations with connectors in the low-code environment without dev help. Meanwhile, devs can focus on core product work.
Standing up and maintaining infra for integrations is time-consuming and requires dev or DevOps effort outside your core product.
When you deploy an embedded iPaaS, your integrations run on the purpose-built infra that abstracts your team's integration security and compliance concerns. Your embedded iPaaS infra also handles scaling and bursting. You can count on your integrations to run smoothly no matter how many there are or how often you run them.
Your embedded iPaaS vendor also handles all infra maintenance, including monitoring, security patches, upgrades, and backups, leaving your team free of integration infra work.
Too often, we treat integrations as services, built as "one-offs" to meet a single customer's needs. Not only does this waste time and create a maintenance headache, but the resulting integration experience is far from ideal. Too often, you deliver unpolished integrations that feel bolted onto your product as an afterthought.
An embedded iPaaS provides everything you need to productize your integrations and deliver them as a first-class part of your product offering. The low-code integration designer lets your team build reusable, configuration-driven integrations for deployment to many customers.
The platform also makes it simple to define a configuration UX for customers or customer-facing teams to deploy integrations with customer-specific configurations.
Finally, the embedded iPaaS provides an integration marketplace you can embed in your product for your customers to explore and self-activate integrations. The result is native integrations that look and feel as polished as the rest of your product.
Embedded iPaaS significantly accelerates teams' ability to deliver integrations by enabling non-developers to build them without waiting for dev resources. This frees teams to rapidly create needed integrations instead of sending them to the integration backlog. Teams can quickly deliver a POC, say yes to a prospect's integration request, reach a new market segment, or meet growing customer needs.
Integrations can be a major source of risk and delay in customer onboarding. New customers' integration needs often get stuck in a dev backlog. When they eventually come to the forefront, there's often poor communication between customers, services teams, and dev teams about requirements.
An embedded iPaaS enables non-developers to build integrations so you can skip the dev backlog and quickly deliver new customers' integrations. They also enable integration delivery by customer-facing teams and provide tools for rapid testing and iteration to ensure new integrations work as expected.
Many teams lack the tooling necessary to provide high-quality support for their customers' integrations. Customers are often the first to know when an integration fails to run. But support staff are left scrambling to determine what went wrong, as they often need to call dev teams to access logs.
An embedded iPaaS gives customer-facing teams a robust integration management environment with logging, monitoring, and alerting tools. This allows them to provide proactive integration support and quickly investigate issues.
The SaaS integration platform also provides end users with logging and alerting tools as part of the embedded marketplace. This empowers customers with a self-serve support experience, allowing them to answer many of their own questions and reducing support volume.
When selecting the best embedded iPaaS for your company, don't forget to:
This sets you up to compare embedded iPaaS vendors and choose software that enables faster and easier integration delivery than your current approach. It's typically helpful to include the product leader responsible for your integration strategy, your integration team leader, and dev team members who've built prior integrations.
You need to prove that the solution can support your unique integrations. Since integrations vary widely, a demo showing a simple link between two common SaaS apps does not necessarily indicate that a platform can support a complex integration between your product and a niche system for which there's no built-in app connector.
For the POC, your team should use the proposed platform to build out one or more integrations that represent the integrations you encounter daily. Many teams build the next integration from their existing backlog.
As part of your POC, investigate whether the embedded iPaaS is sufficiently powerful and flexible to support the range of integrations you need.
Integrations in the real world are complex. Almost every B2B integration is "messy": imperfect third-party APIs, non-standard auth, data mapping that varies widely between customers, automatic retry needs, etc. Ensure that the solution you're considering handles the integration complexity you tend to encounter.
Extensibility is critical. Many B2B software teams serve customers in niche vertical markets and often need to integrate apps or use logic specific to those markets. If that is your situation, you'll want to consider that even the largest library of pre-built connectors won't include ones for those niche apps.
That's why choosing a platform that offers robust custom connector (or custom component) support is vital. Custom API connector support varies widely between embedded iPaaS solutions.
Some do not offer custom connector support at all. Some only allow you to build lightweight custom connectors that wrap APIs. Some allow you to build real custom API connectors but require that the vendor publish them, making it hard to build and iterate quickly.
As part of your proof of concept, confirm that your solution offers a dev-friendly SDK for writing robust, reusable custom API connectors. Then build and publish a connector. This test ensures you can extend your embedded iPaaS solution's low-code integration designer to fit your product and industry.
As you evaluate each embedded iPaaS option, see if it fits your use case and if the vendor's primary focus is B2B software.
Some embedded iPaaS solutions are provided by vendors who built traditional iPaaS and later extended them to create embedded iPaaS. Those solutions can feel like "retrofits" lacking critical functionality because they were designed for internal workflow automation, not customer integrations.
Finally, for almost any software tool to be successfully adopted, it should fit into your current dev ecosystem.
Examine solutions to see if they will easily merge into your existing tools and processes, such as source control, CI/CD pipeline, logging systems, and incident response systems. This ensures you can smoothly incorporate your integration delivery into building, deploying, and supporting your core product.
Delivering integrations to your customers can be demanding. Typically, it takes a lot of dev time, slows your sales and onboarding efforts, and distracts from core product work. For many B2B software teams, integrations represent a weak point in the customer experience.
Embedded iPaaS offers a proven, scalable solution for customer integrations and can help you transform your integration delivery into a decisive strategic advantage.
Prismatic is a powerful embedded iPaaS designed to give software teams a better way to provide integrations to their customers. Contact us to learn more about building a scalable integration strategy for your product.
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.