As the number of SaaS products every company uses continues to go up every year, end-users’ expectations for integrations have grown. To remain competitive, SaaS businesses face a choice—accelerate the pace at which they build new integrations, or experience slower growth due to an inability to meet prospects’ and customers’ demand.
Traditionally, engineering teams have had to build every integration from scratch. They would have to build authentication for every integration, read and understand every 3rd party app’s API docs, maintain the API references over time, and build the configuration experience for their end-users. At a minimum, a single, simple integration takes companies 4-6 weeks of dedicated engineering to build - and that doesn’t include the maintenance and iteration efforts required for the lifecycle of the product.
Thankfully, embedded iPaaS solutions, such as Paragon, have emerged to address this challenge. This article will explain the benefits of embedded iPaaS and why every B2B SaaS company should consider leveraging one to scale its integration strategy.
While you may be familiar with the term iPaaS, let’s first make clear the differences between traditional iPaaS solutions and embedded iPaaS solutions.
What is an iPaaS?
An integration platform-as-a-service (iPaaS) is a workflow automation tool that enables SaaS buyers to build automations between the different apps within their tech stack.
These solutions have exploded in popularity by providing non-technical operations teams the ability to string together their own workflows, as the SaaS applications they used were not providing the required integrations out of the box.
The most common iPaaS solutions are platforms like Zapier, Workato, or Boomi (for enterprise).
However, the experience is far from ideal, as these integrations are brittle (no auto-retry), only enable the most simple use cases, and are a pain for teams to maintain.
What is an embedded iPaaS?
Embedded iPaaS solutions tackle the integration challenge at the application layer, by focusing on providing the product and engineering teams building the SaaS products a way to build native integrations significantly faster.
The end goal? Make it so easy for SaaS companies to build the native integrations their customers need that their end-users will never have to use an iPaaS.
Before the rise of the embedded iPaaS, only a handful of companies like HubSpot, Slack and Salesforce managed to provide this seamless native integration experience at scale across hundreds of integrations. While technically possible, this required years of engineering (and engineering salaries).
Thanks to the tooling, such as pre-built connectors, that embedded iPaaS platforms provide, fast-growing SaaS companies can deliver new integrations in a matter of days. This drastically simplifies the tradeoff decision of deploying engineers away from working on the core product for months. With an embedded iPaaS, your business can deliver integrations requested by new prospects at a pace that protects the integrity of your sales cycle.
But why not build integrations in-house?
As an engineering-focused company, we understand why SaaS companies want to build everything in-house rather than buy ready-made solutions. While we won’t go deep into the build vs. buy discussion here, here are a few high level challenges that comes with building integrations in-house:
- Building and maintaining authentication mechanisms for each integration
- Securely handling access and refresh tokens
- Combing through reams of esoteric third-party APIs
- Debugging customer issues and bugs with a lack of observability
- Maintaining integrations and auto-scaling for increased task volume
Ultimately, engineering salaries are among the highest in every SaaS company. So assuming an average software engineering salary of $150,000, dedicating 6 weeks to a single integration will cost you nearly $20,000. And if you want to build multiple integrations in a year, the costs of those integrations quickly pile up, making them much harder to prioritize.
Embedded iPaaS solutions streamline the building, deploying, and maintenance integrations, providing you incredible efficiencies.
Saving engineering resources
For example, on average, Paragon’s customers have seen a >70% reduction in engineering resources required to build the first integration, with that efficiency further improving on subsequent integrations due to familiarity with the platform.
As you continue to scale your integrations, those efficiencies will compound.
Faster time to market
What comes hand in hand with the resources savings is that equipping your engineers with an embedded iPaaS will enable integrations to be shipped in under a week, by offloading all the infrastructure work and providing elegant API abstractions.
This accelerated speed to market with integrations puts your business in a position to respond to integration requests quickly, whether it be to close deals for the sales teams or to improve the product experience for your existing customers.
Not only does this enable you to react more quickly, it also unlocks the ability for you to think more proactively about your integration strategy.
For example, what integrations can you build to unlock more of your TAM, whether it be through supporting more integrations within an existing category, or unlocking new user personas through new ones?
These are questions that you would otherwise not have the luxury of entertaining if even the most table stakes integrations are getting backlogged for months.
With all that said, let’s dive into the specific features and benefits of using an embedded iPaaS.
What are the key benefits of using an embedded iPaaS?
1. Pre-built integrations
Reading up on terribly structured 3rd party API docs is not an enjoyable experience. Yet every time you want to build a new integration, or revisit an existing integration, your engineers will inevitably have to familiarize themselves with the 3rd party API.
Most embedded iPaaS solutions provide pre-built integrations (also referred to as connectors) that abstract away certain endpoints, enabling users to build the most common use cases without having to go through the docs.
Essentially, the engineering teams at the solutions providerAdditionally, the workflow builders also enable solutions engineers/architects, or even technical product managers to build new integrations, which can further offload integrations from your core engineering team.
Ultimately, these resource savings free your engineer team from the burden of working on integrations, enabling them to dedicate their time and effort on your core product.
2. Scalable infrastructure
The more integrations you build, and the more customers you have using those integrations, the harder it gets to handle the volume of requests. Supporting the scale that comes with that growth will almost always require multiple refactors, because you can’t afford to spend months of engineering early on to build the perfect, scalable integration infrastructure when you have piles of competing roadmap and engineering priorities to get to.
By contrast, if you use an embedded iPaaS, you will be relying on the platforms’ hosted infrastructure. While not all platforms have been built to handle the same scale, platforms like Paragon have been load tested to handle hundreds of millions of requests.
Side note: Paragon is one of the only solutions that provide a managed on-premise deployment option to support even the strictest security requirements.
3. Built In Auto-retry
As minor as auto-retry may seem to some, not having auto-retry mechanisms built into your integrations can lead to data loss and ruin your customers’ product experience in the process.
Intermittent errors are bound to occur, whether it be due to 3rd party API outages or hitting API rate limits. The last thing you want is for these integrations to error out on the first try.when your customers have critical business processes relying on them.
Embedded iPaaS solutions like Paragon provide auto-retry out of the box, enabling your engineers to focus purely on implementing the defined integration logic.
4. Offload integration authentication
Building and maintaining authentication mechanisms for each and every integration manually is complex and time consuming, both from an engineering and security perspective. If you don’t manage access and refresh tokens appropriately, your customers’ integrations will no longer be authenticated properly, which can break the processes they rely on for their day to day work.
On top of that, if you don’t store your customers’ 3rd party credentials securely and their data gets compromised, it can cause irreparable damage to your company.
We constantly put our authentication layer under full sets of penetration and security tests, to ensure your customers’ data and credentials are stored securely, and ensure that all your customers’ tokens are refreshed pre-expiry for you, so your team doesn’t have to.
5. End-user configuration
Building an integration involves not only defining the integration logic and expected behavior of the integration, but also providing customers a seamless experience when enabling/configuring the integration.
At the most basic level, you need to allow customers to enable an integration and trigger the 3rd party app’s auth portal. However, in many cases your customers will want the ability to customize the behavior of an integration.
Whether that’s defining which object to map data to, or defining their own schema for mapping custom fields, building a configurable experience for you customers can quickly become a huge headache.
While most embedded iPaaS providers provide some form of an out-of-the-box UI for your customers to interact with, only Paragon provides all of the following:
- A fully white-labeled and native modal
- In-app integration marketplace/catalog
- Support for user-defined settings and custom field mapping
- A headless SDK to support your own custom UI
6. Accelerated incidence response
If you build your integrations in-house, you’ll know that customer support for integrations is notoriously challenging - it’s almost impossible to pre-empt when and where issues will arise.
Unless you have months of engineering resources available to build an internal tool for your support team that allows them to manage and get insights on your customers’ integration states, your engineers will be forced to help debug even the most simple integration issues.
The result? Slow incidence response times, more expensive frustrated customers, and possibly, higher churn.
Conversely, embedded iPaaS platforms provide logging features out of the box that can give you visibility into each execution.
For example, Paragon enables you to look into every workflow and individual step execution, making it extremely easy to see exactly what occurred if and when an error occurs.
However, we take it a step further with our Connected Users Dashboard, by providing a user-centric view to analyze and manage each of your customers’ integration states, as well as their task histories.
This way, even your customer support team can quickly identify and start addressing problems, and decide intentionally whether or not engineering needs to be looped in. This drastically accelerates response time, which creates a better experience for your customers, and saves your engineering team a lot of effort debugging any non-technical issues.
7. Offload maintenance on integrations
Many SaaS companies overlook the running costs of maintenance when they build integrations, because it’s easy to be tunnel-visioned on going live. Integrations are like any other product feature and require constant iteration and improvement, yet many product and engineering teams still see it as a ‘set it and forget it’ feature.
However, maintenance can compound over time as you scale your integration roadmap, and here are the four most common aspects of integration maintenance:
- Updating API references for existing integrations when the 3rd party applications release breaking changes to their APIs
- Updating existing integrations when your own product and/or API releases breaking changes that impact the integration
- Iterating on the behavior of an existing integration to improve the end-user’s experience, or add functionality on top of the existing integration
- Debugging customer issues
Breaking changes in the 3rd party API
If the 3rd party API you’re interacting with changes, the endpoints you use to implement the integration logic may no longer be valid.
However, with an Embedded iPaaS, if you’re building an integration using the pre-built actions provided by a connector, the embedded iPaaS provider will be responsible for maintaining those API references.
Adapting to changes in your product
Similarly, if the data or module of your product that the integration interacts with changes, you may need to update the integration logic to accommodate those updates.
Iterating on existing integrations
Whether it’s to provide additional functionality within an integration, or to improve the user experience of an existing integration feature, integrations evolve over time. Once you launch the initial iteration of an integration, you will get feedback from customers on how to improve the integration, and requests for supporting additional use cases will often come up.
As a result, your engineering team will have to revisit integrations after they go live, and an embedded iPaaS solution will drastically reduce the resources you will need to dedicate towards updating existing integrations.
Debugging customer issues
When a bug occurs within your own product, your engineering team needs to look through the customer’s account to see if it’s a user-specific issue or a more generalized bug that needs to be fixed. However, given that they are in your product day in and day out, it becomes a lot easier to identify what went wrong.
With integrations, that workload more than doubles, as there are additional dependencies involved. The bug could be caused by issues within your own product, within the 3rd party product, or within the integration logic.
Most embedded iPaaS platforms provide a history of integration executions that can help your team easily identify the root cause of these errors, by surfacing where exactly an execution (or series of executions) errored out.
Paragon takes this a level further, by providing log streaming capabilities as well as a Task History API that makes it even easier for developers to debug any customer issues.
Picking the best embedded iPaaS solution
What we’ve just covered is a generalization of benefits that are commonly offered by embedded iPaaS solutions. Unfortunately, many solutions fall short as they were not built specifically for the embedded use case nor designed for developers.
If you’re evaluating the best embedded iPaaS solutions, use this article as a checklist to guide your search. You’ll quickly notice that Paragon provides an unparalleled developer experience for your team, and will enable you to go to market with new integrations faster than any other embedded iPaaS.