How to Scale Integrations for Your B2B SaaS Product

SaaS integrations can appear simple on the surface: write code that allows System A to connect with System B and transfer data between the systems. Done.

And that may be true for that first integration or so. After all, your dev team reviewed the requirements and said, "Yes, we can do that." It's possible that building your second or third integration also went well.

But at some point, you, your dev team, and even your customers realize that the traditional, one-off approach you're using to build integrations won't work at scale. Your customers' need for integrations keeps growing, but your integration challenges are growing even faster.

Why do you need to scale integrations?

You may have dozens of customers today, but you'll have hundreds or thousands next year. And, based on current trends, each customer will use more apps over time (one 2020 report notes that mid-market businesses use an average of 137 apps). So you'll need to create even more integrations to keep pace. One way or the other, you'll end up with many customers and many integrations.

Scaling to handle all those integrations for all those customers? That's where an embedded iPaaS (or embedded integration platform) can help and we'll use the rest of this post to examine how that works.

But first, let's look at some of the problems you can have when trying to scale integrations without an embedded iPaaS.

Problems that arise when scaling integrations

As noted, scaling integrations brings its own challenges. Some are simple; some are not. But all of them must be addressed to scale your SaaS product integrations successfully.

• How do you scale integrations without scaling all the teams (engineering, onboarding, and support) that handle the integrations? You can't afford to double, triple, or quadruple the size of your teams to address integrations. You've got to figure out how to do more with less and execute on X times the number of integrations you have now, but without increasing your staffing linearly.
• How do you ensure you don't accrue substantial tech debt when scaling integrations? Let's say you've got plenty of dev resources and are building several integrations simultaneously. How are your teams attempting to future-proof those integrations? Or are they simply knocking out as much code as they can as quickly as they can to take care of customers? If that's the case, how much future time will be spent rebuilding/refactoring those integrations?
• How do you ensure sufficient resources remain available for your core product? While a single integration may not require many resources, building out a dozen of them changes the equation. How will you ensure that your devs can primarily focus on your core app and not end up buried in integration work?

4 areas for successful integration scaling

From working with our customers, which are B2B SaaS companies across a wide number of industry verticals, we've determined that scaling integrations comes down to these four areas:

• Development
• Deployment
• Support
• Infrastructure

Let's look at each area and see how an embedded iPaaS helps your teams avoid common issues while successfully scaling your B2B SaaS integrations.

Scaling integration development

Most SaaS teams think of development first, if only because it's what comes up early in the process. If two devs can build two integrations apiece per year, what will it take to support 100 new integrations in a year? It's easy to see that adding 49 more devs is not a sustainable path.

Fortunately, an embedded iPaaS (embedded integration platform) includes a low-code integration designer, API connectors (and other built-in integration components), the ability for devs to write any code needed for niche or vertical scenarios, and an embedded designer for end users, and a dedicated infrastructure.

The low-code integration designer and existing API connectors mean you can shift much of the integration development onto non-devs. If you want to keep it where devs do the bulk of integration development, an embedded iPaaS will still expedite the integration process by ensuring that some portion of the integration (30%, 50%, 80%) is pre-built.

Your devs can also write custom API connectors to integrate with any application your customers use, no matter the industry. And, for scenarios outside the norm, allowing devs to write code ensures that your team never ends up short of the goal because of low-code designer limitations.

Scaling integration deployment

Once you've figured out how to scale the development of X integrations, the next step is determining how to deploy all those integrations efficiently to your customers.

An embedded iPaaS includes an integration marketplace and the ability to productize your integrations. In addition, with integrations being built and deployed much more quickly than with a traditional development approach, you can set up new customers with integrations as part of your core product onboarding process.

The integration marketplace allows you to make your integrations accessible to internal and customer users for listing, searching, and deployment. As such, the integration marketplace showcases your integrations as essential product functionality (instead of the behind-the-scenes role that integrations often have).

To assist with scaling integration deployment, you can productize your integrations by specifying the configuration values/options that are unique per customer. These values often pertain to auth and endpoints but can include almost anything. This configurability means your team can build a single integration and then deploy it to dozens (or hundreds) of customers without deploying different code for each customer.

Scaling integration support

Having many integrations only helps you move your product forward if your support team isn't buried in trouble tickets.

An embedded iPaaS includes logging and real-time monitoring and alerting. These functions help you scale integration support internally and externally.

Internally, your customer-facing teams can stay abreast of everything: what integrations are deployed (and for which customers), the status of every integration, what alerts have been triggered, and much more.

Your team gains insights that can warn them of issues before they become critical, allowing them to provide proactive support for integrations.

Externally, your customers can have a similar level of insight, allowing them to see the logs, set up monitors, and get alerts on their integrations. In addition, they can update configurations and perform first-level troubleshooting when there are problems. As a result, your customers send fewer support issues your way.

Finally, by putting so much control into the hands of your support team and your customers, your devs only need to provide support for those issues that your support team and customers can't resolve themselves.

Scaling integration infrastructure

For B2B SaaS integrations, infrastructure resources are often poorly calculated or overlooked entirely. Yes, integrations may be relatively small, discrete applications, but deploy them to a few hundred customers and watch the I/O, CPU, and memory usage climb rapidly.

An embedded iPaaS includes a cloud-based infrastructure that scales horizontally to match the integration load. No matter how many integrations and customers you have using the platform, resources are continuously reallocated to ensure optimal performance.

Integration loads can be highly irregular. Based on the time of the day, they may drop to almost nothing but then jump from that to thousands of operations per second in a few minutes. An embedded iPaaS also includes capabilities to address this type of bursting behavior, ensuring that integrations have necessary resources despite load variability.

For those who build out their integration infrastructure, only to watch it fall over when all their customers run an integration simultaneously, using an embedded iPaaS with its secure, scalable infrastructure makes all the difference.

Are there limits to scaling integrations?

Certainly. No system is without limits. But practically speaking, an embedded iPaaS can handle the massive numbers of integrations and customers that today's B2B SaaS systems require.

And by simplifying and streamlining the integration build, deployment, and support processes, an embedded iPaaS allows you to make the most of the dev and non-dev resources you already have. Everyone benefits when you can turn integrations around more quickly, configure them appropriately, deploy them to a broad range of customers, and keep them running around the clock.

Implementing an embedded iPaaS for your integrations allows you to not only scale on demand, but also to ensure that your integrations become first-class features of your product.

Schedule a demo and we'll show you how our embedded iPaaS can support your integration scaling needs.