Reducing Integration Workload for Your Engineering Team

When it comes to providing customer integrations, most B2B SaaS companies aren't happy with how they're doing things. Opinions range from "this isn't great" to "this is a total dumpster fire and there has to be a better way."

There are a handful of common things we see B2B SaaS teams wanting to improve about their integration strategies. And the goal that usually tops that list? Reducing the integration workload on engineering teams.

Let's dig into why integrations take so much engineering effort and how an embedded integration platform like Prismatic can help.

Integrations can take a ton of engineering time

If you're like most B2B SaaS companies, you spend a ton of engineering time providing integrations connecting your product to the other systems your customers use.

Why is that?

To start with, integrations are often incredibly complex.

There's simply a lot to do!

• Writing bespoke code to connect with a variety of third-party systems.
• Standing up infrastructure to run integrations and ensuring it's stable and secure.
• Finding ways to test integrations and implement logging.
• Enabling customers to do their own configuration, monitoring, and troubleshooting.
• Managing customer-specific configurations.
• Troubleshooting and fixing issues that come up in production.

Not only is there a lot to do, but the bulk of it typically falls to engineering teams.

Here's why: most customer-facing teams lack the tools they need to do the integration work that makes sense for them to handle.

Regarding core product features, customer-facing teams typically have the tools and resources to answer customers' questions, help with configuration, and troubleshoot if something goes wrong.

All too often, none of that holds true for integrations:

• Questions: Many customer-facing teams don't have the resources to quickly answer basic questions about integrations like "Is there an integration to Acme Scheduling? Is it one-way or two-way? What data gets passed?" As a result, those teams end up requesting this information from engineering.
• Configuration and deployment: When it's time to set up an integration for a customer, many customer-facing teams can't simply direct users to a config screen. Instead, they often have to gather auth and config info from customers and pass it to dev teams to do the actual setup. And that usually involves a lot of slow, lossy back-and-forth that feels like a bad game of telephone.
• Troubleshooting and support: Many customer service teams' hands are tied when a customer's integration fails or does something unexpected. Most customer-facing teams lack access to integration logs and can do little more than ask engineering to investigate. If a customer needs auth changed or to upgrade to a new version of an integration, support must get engineering involved. Cue more back-and-forth.

Consequently, dev teams often end up not just doing the part of integration work you might expect – building integrations – but also staying heavily involved with integration deployment and support over the long term. Most of that work is unscheduled, so even more time gets lost to context switching.

What about core product development?

You can see why integration work consumes so much engineering time, one of a B2B SaaS company's most precious resources.

Here's the biggest problem – all that integration work reduces capacity for core product development. For startups, that can add weeks or months as you race to get your product to market. For more established teams, it can slow the pace of innovation and cause your product to stagnate.

And, as your customer base grows, so does the number of systems they want you to integrate with, the number of ways they want those integrations to work, and the number of integration support issues you need to handle. Before long, you're spending a substantial percentage of your dev capacity – often upwards of 25% – on integration work.

That leaves little time for the core product innovation that keeps your offering competitive.

Prismatic reduces the dev integration workload

It's easy to see why B2B software companies so badly need to reduce the integration workload for their dev teams.

That's where we come in.

Prismatic is an embedded integration platform designed specifically to give B2B software companies a better way to provide integrations to their customers. And a key part of "a better way" is "a way that requires less engineering time."

Prismatic reduces the integration workload on dev teams by:

1. Empowering non-devs to build integrations.
2. Allowing non-devs to deploy and maintain the integrations
3. Enabling customers to build, activate, and maintain their own integrations.
4. Providing a purpose-built infrastructure so devs don't need to develop and maintain integration infrastructure.

Let's look first at how Prismatic empowers non-dev teams to build integrations.

Non-devs build integrations with a low-code designer

With Prismatic, non-dev team members can create integrations by assembling components in an intuitive low-code designer. We provide built-in components that handle much of the work in your integrations: triggers, logic, data transformation, API connectors, and more.

Auth is handled, versioning is handled, and a testing framework is built right in. Integrations built in Prismatic are reusable and can be deployed to multiple customers with different configurations and credentials. As part of building an integration, you define a straightforward configuration UX that makes it easy for customers and customer-facing teams to set up their integrations.

A low-code integration platform only works for a B2B SaaS company if you can tailor it for your product and industry. Our custom component SDK makes it easy for your devs to write custom components that extend the platform to work for you.

For example, if you your SaaS builds project management software for rocket companies, your devs might write custom components that convert fuel from pounds to gallons and connect to other rocket software APIs. Custom components are reusable, so your devs build them once, and then non-dev integration builders can drop them into any integration as needed.

With this approach, devs only need to be involved where they add the most value – extending the platform to work for you. Building and testing integrations end to end? Coordinating with third-party vendors to ensure everything's correct? With Prismatic, non-devs can do all those things while devs focus on core product work.

Of course, your devs can still build integrations if that's what works best for your team – and many teams even use a combination of devs and non-devs to build integrations in Prismatic. Brian Steinbach, Chief Architect at Elastic Path, describes how his teams use Prismatic to share the integration building workload:

"More straight-forward integrations can be created using pre-existing components exclusively within the low-code visual editor. This is an excellent feature for less technical team members. More complex integrations can be built by writing code and publishing custom components before wiring together in the visual editor. This is a very powerful feature for more technical team members to use when constructing our most complex integrations."

Customer-facing teams also deploy and support integrations

Next, Prismatic provides a simple management environment that gives customer-facing teams everything they need to deploy and support integrations.

As mentioned earlier, integrations built using Prismatic are reusable and heavily configurable. (Some customers need the integration to convert units, and others don't? Make it configurable!) When someone builds an integration in Prismatic, they also design a simple configuration UX, which customer-facing teams use to deploy that integration to each customer who needs it.

This makes it extremely straightforward to set config options, enter auth, and turn it on! Customer-facing team members from onboarding, services, or support can do this independently, without involving devs at all.

Our management environment also provides all the tools and resources that customer-facing teams need to deliver high-quality integration support.

Prismatic is an accessible, centralized repository for integration info. Because of this, customer-facing teams can answer customer questions without consulting devs. They can see a list of the integrations you offer and, because Prismatic integrations are self-documenting, easily understand what they do.

You can also upload documents such as design specifications or troubleshooting steps – whatever your teams need. They can easily see which customers have which integrations enabled, how those integrations are configured, when they last ran, if any errors have occurred, and so on.

Configurable monitoring and alerting ensure appropriate teams are notified when an integration encounters an error or doesn't run when expected. Built-in logging makes it easy to dig in and troubleshoot.

Customer-facing teams can easily handle everyday needs like updating auth, tweaking a configuration, or upgrading to a newer version of an integration.

Putting all these tools in the hands of your customer-facing teams greatly reduces the time your devs spend supporting integrations.

Customers can build, activate, and maintain their own integrations

In addition to having your non-devs do integration work that was traditionally the domain of devs, you can embed a white-labeled customer integration marketplace within your product to enable customer self-service. Customers can view all available integrations via the integration marketplace, configure and activate those integrations, and monitor them with Prismatic's logging and alerting tools.

Beyond the marketplace, our embedded designer lets your customers build integrations between your product and other apps they use. All those one-off integrations your customers would like to have but don't make sense for your devs to build? Set your customers up with the embedded designer, and they can build everything they need.

Enabling this level of customer self-service reduces the integration workload not just for engineering but for your entire organization.

Take advantage of pre-built, secure, scalable infrastructure

Finally, Prismatic reduces engineering workload by eliminating the need to spend time on integration infrastructure.

Traditionally, engineering teams are responsible for standing up and maintaining infrastructure to run their customers' integrations. That can be highly time-consuming.

With Prismatic, your integrations run in our purpose-built environment. It was created using modern technologies and architecture and designed to handle all the scalability, security, and performance concerns associated with integrations. That saves you the effort of standing up that infrastructure yourself and prevents many issues that can crop up in production.

Prismatic handles all the monitoring and maintenance, like upgrades, security patches, and backups, making integration infrastructure a thing you simply don't have to worry about.

Where would you like to spend your dev time?

B2B SaaS integration development can quickly grow to the point that it consumes a large percentage of your development resources. That hurts your core product development and can derail your product roadmap. But implementing Prismatic can help your B2B SaaS company regain one of your most valuable resources: engineering capacity.

Schedule a demo to see exactly how our embedded iPaaS can save time for your team.