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.

Today's software companies face a huge challenge because of this expectation. Along with their apps, these companies must deliver dozens – sometimes hundreds – of integrations to their customers' other apps and services. Often, these integrations are table stakes for getting to market, winning deals, and retaining customers.

How can you provide these integrations?

Given all of this, how will you quickly deliver the integrations your prospects and customers need? How will you maintain and support them? As your customer base and integration demands grow, how will you do this at scale? Will you be able to do it without using too many dev resources and without 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.

What is an 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.

Types of embedding options

An embedded iPaaS can become part of your SaaS app in several ways. However, using an iframe or a custom UI are the most common.

Embedding with an iframe

When you use an iframe, the embedded iPaaS displays as another page of your app. To complete the experience, you can change elements such as logos colors to theme the embedded marketplace to match your app. And users authenticate to your app (not the embedded iPaaS). This is the easiest option since you only need to configure the UI and write very little code.

Embedding with a custom UI

When you use a custom UI, you are working with an API for the embedded iPaaS. You have complete control over all UI elements (because you are building them), so you can design and create an embedded marketplace to precisely match your requirements. Once again, users authenticate directly with your app. This option is more work to implement than the SDK option but provides complete control over the user experience.

Features of an embedded iPaaS

A comprehensive embedded iPaaS includes the following features:

✓ A low-code integration designer that empowers non-developers to build and test productized integration workflows that can be configured and deployed to multiple customers. A full-featured designer lets non-devs assemble integrations from existing connectors while making it easy for developers to write needed custom connectors to solve real-world integration needs. A built-in testing framework enables continuous testing for rapid iterative development. Flexible configuration options mean that users can build integrations once with the flexibility to deploy to many different customers. Documentation can be created and stored directly in the designer and attached to the pertinent integration.

✓ 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. These components include API connectors and various other components, such as those for changing data formats, data mapping, text manipulation, and performing math or other logic functions. Auth flows such as OAuth 2.0 are intrinsic to the API connectors. In addition, the library is easily extensible, allowing developers to build any functionality needed for a product or industry.

✓ An integration marketplace that teams can white-label and embed in their product to provide end users with a self-activated, in-app integration experience. The marketplace support viewing, sorting, and activating integrations. As noted earlier, embedding this marketplace can be as simple as using an iframe with simple theming options, or devs can work with an API to build a custom UI for the marketplace. The marketplace allows SaaS teams to increase the visibility of native integrations for customers and prospects alike.

✓ An embedded designer that enables customers to build their own integrations between a software company's B2B SaaS product and other apps they use. This allows SaaS teams to say "yes" to highly-specific integration needs without having to spend dev time building and maintaining bespoke integrations that don't benefit their broader customer base.

✓ Integration deployment and support tools that enable customer-facing teams to configure, deploy, monitor, and troubleshoot customers' integrations without dev involvement. Teams can not only configure and deploy integrations to dozens or hundreds of customers, but they can also set up monitoring for those integrations to alert them (or anyone else) to various integration states. And when alerts are triggered, users can dig into the corresponding logs to determine precisely what happened, when, and if the issue lies inside or outside the integration.

✓ A cloud infrastructure that runs integrations and handles scalability, security, and compliance concerns. Whether a team needs to run 10 integrations once per day or 100 integrations 10 times a day, the infrastructure scales horizontally to support that need. In addition, the vendor provides all needed upgrades, security patches, and redundancy for the infrastructure, allowing SaaS teams to work on core applications rather than the back end of integrations.

What does iPaaS stand for?

To understand embedded iPaaS, let's first look at enterprise iPaaS (traditional iPaaS).

The term iPaaS stands for integration Platform as a Service. The majority of iPaaS solutions available today are enterprise iPaaS. These platforms help companies connect the SaaS apps in their tech stack and automate their internal processes.

There are many enterprise iPaaS solutions on the market. Well-known platforms such as MuleSoft and Boomi fall into this category.

Enterprise iPaaS vs embedded iPaaS

Enterprise iPaaS solutions are general-purpose platforms businesses use to create integrations for internal purposes. An enterprise iPaaS scenario might have a dev with your company pulling data from several scheduling systems to publish it to a single calendar on your company's intranet.

Embedded iPaaS solutions, by comparison, are purpose-built SaaS integration platforms software companies use to create native integrations for their customers. Let's say your SaaS company provides a CRM to its customers, who need to connect various contract management systems to your CRM. This scenario is best handled with an embedded iPaaS.

For a detailed discussion of the differences, check out our post on embedded iPaaS vs enterprise iPaaS.

Who is embedded iPaaS for?

Any B2B software company that needs integrations for its customers can use an embedded iPaaS. Embedded iPaaS solutions are used by startups, scale-ups, and enterprises. SaaS companies in every industry segment can benefit from embedded iPaaS.

In addition, members of product, dev, customer service, and customer support teams for these software companies can all benefit from the efficiencies of an embedded iPaaS. Devs, in particular, save substantial time because they are no longer coding integrations from scratch. Similarly, customer support can resolve many issues without involving devs because of the monitoring and troubleshooting data made available via the embedded iPaaS.

Why are integrations so important for B2B SaaS companies?

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 drive 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 want to be able to set up and operate their apps without constantly relying on IT. This thinking also extends to integrations.

How can you use integrations as a strategic advantage?

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.

  "It was easier for us to identify the data coming into the system and to add fields. Now we could pull that data in and all of a sudden it was unlocking additional functionality for customers."
  

  
  Adam Jacox, VP of Engineering for Hatch. Read Hatch's full story here.

• 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 with the same integration.

  "Customer retention and annual revenue per user or subscription, both of those have significantly changed since we've got the Prismatic embeddable solution baked into our product. Our churn month over month has gone down, I'd say, almost 3%."
  

  
  Frank Felice, CRO of Sisu Software. Read Sisu's full story here.

• Be strategic about what not to build. When the market asks for a feature with serious 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.

Common approaches to integration delivery

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 the ways SaaS companies commonly deliver their integrations.

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 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 to your customer relationship.
• Customers in many markets won't accept it.

Use an enterprise iPaaS and build around it

Some SaaS teams find creative ways to use enterprise 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 an enterprise iPaaS does not address:

• Enterprise 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 enterprise iPaaS for customer integrations must deploy an instance of the iPaaS 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 an enterprise 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.
• Enterprise 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 includes other concerns:

• 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.

Signs you would benefit from an embedded iPaaS

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 those indicators, grouped by your company's 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, 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 scale-up 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.

Benefits of an embedded iPaaS

Given the value of customer integrations and the challenges with standard delivery approaches, B2B software companies need a better solution. Embedded iPaaS has evolved to give B2B software companies a more efficient, cost-effective, and scalable strategy for customer integrations.

Here are several good reasons to adopt an embedded iPaaS:

Reduce engineering effort

Building integrations and integration tooling in-house takes much dev time and resources. Using an embedded iPaaS significantly 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. In addition, an embedded designer allows customers to build their own integrations.

Raven Industries reduced dev time per integration by 80% after implementing Prismatic. Read Raven's full story here.

Offload infrastructure 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 infrastructure work.

Productize your integrations

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 not 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.

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.

Finally, an embedded integration enables your customers to build their own integrations between your product and other apps they use. This allows you to say "yes" to unique integration needs without having to spend dev time building and maintaining custom integrations.

Hatch uses Prismatic to build productized, highly-configurable integrations their customers can self-activate. Read Hatch's full story here.

Respond faster to customer and market demands

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 request, reach a new market segment, or meet growing customer needs.

Onboard new customers faster

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 allow integration delivery by customer-facing teams and provide tools for rapid testing and iteration to ensure new integrations work as expected.

Provide better integration support

Many teams lack the tooling 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. This empowers customers with a self-serve support experience, allowing them to answer many of their own questions and reducing support volume.

Tips for evaluating embedded iPaaS solutions

Selecting the best embedded iPaaS for your company is a critical step toward laying a foundation for all your future integration work. Here are a few tips we've collected for making the most of your evaluation process:

Include the right stakeholders in your evaluation

This sets you up to compare embedded iPaaS vendors and choose software that enables faster and easier integration delivery than your current approach. Including the product leader responsible for your integration strategy, your integration team leader, and dev team members who've built prior integrations is helpful.

Confirm that the solution supports your big-picture requirements

Once you have identified the stakeholders, they should perform a hands-on evaluation of the embedded iPaaS within a test environment. If the platform doesn't provide tools to support your minimum functionality or requires a level of technical know-how your team doesn't possess, it's probably time to look elsewhere. If you have a few integrations now but plan to have dozens (and hundreds of customers using them) in a year or two, can the platform scale to support that?

Get a demo early in the process

After the test drive, get a detailed demo from the vendor. Bring up any questions you noted during your testing. It may be that needed functionality was there but not easily seen. Check your assumptions with the vendor and ask the hard questions. If you have specific use cases that might not work with the platform, bring them up in the demo and see how the system handles them. In short, use the demo to fill the remaining gaps in your understanding of the tool.

Conduct a realistic proof of concept

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 pick the next integration from their existing backlog.

Verify the solution's ability to handle real-world complexity

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.

Confirm the platform's extensibility and custom connector support

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, consider that even the most extensive library of pre-built connectors won't include ones for those niche apps.

You want to confirm that the solution you choose 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.

Ensure that the solution fits your existing tools and processes

Finally, for almost any software tool to be successfully adopted, it should fit into your dev ecosystem.

Examine solutions to see if they will 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.

Embedded iPaaS Comparison

With all the different embedded iPaaS solutions, how do you find the best embedded iPaaS for your scenario? It may take some work, but it comes down to finding the one that best meets your requirements – now and in the future.

Here are some of the top embedded iPaaS solutions:

Prismatic: Purpose-built for the embedded iPaaS market, Prismatic supports both low-code and custom-code approaches to building integrations. Fully incorporate the integration development process with your existing dev tools, and allow non-devs to build, deploy, and support the integrations. Pull in devs as needed when custom code is required. And allow customers to select, activate, configure, monitor, and troubleshoot their integrations. Sophisticated customers can be set up to build their own integrations within your app. With everything running on a fully scalable, secure, cloud-based infrastructure.

Tray.io: An enterprise iPaaS company that pivoted into the embedded iPaaS space, Tray.io focuses primarily on its many app connectors and no-code integration designer. As a result, it offers a less flexible toolset than other platforms.

Workato: Another enterprise iPaaS company with an embedded iPaaS offering, Workato offers both a low-code designer and the ability to write custom components (though only with Ruby). The platform takes much longer to implement than many other embedded iPaaS solutions.

Paragon: Built for simpler integrations, it also offers functionality to build custom connectors (but only to REST APIs). Its embedded marketplace can list interfaces built with Paragon and bespoke ones.

Cyclr: Once a general-purpose automation platform, Cyclr has moved firmly into the embedded iPaaS market. The focus is on no-code connectors, with no actual capacity for devs to create custom code/custom connectors. Customers can activate integrations, but they can't monitor them.

Zapier: Very much begun as an enterprise iPaaS, the company's embedded offering supports B2B SaaS scenarios. However, your customers must authenticate to Zapier, contact Zapier for support, and are otherwise reminded that they are Zapier customers.

To help determine the best embedded iPaaS for your needs, view all the embedded iPaaS solutions in G2's Embedded Integration Platform category or download G2's latest Grid® Report for Embedded Integration Platforms for an in-depth look at top-rated solutions.

Embedded iPaaS supports a scalable integration strategy

Delivering integrations to your customers can be demanding. Typically, it takes a lot of dev time, slows your sales and onboarding efforts, and distracts you from core product work. For many B2B SaaS companies, 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.