Reducing Integration Workload for Your Engineering Team

When it comes to providing customer integrations, most B2B software companies aren't exactly happy with the way they're doing things. Opinions seem to range somewhere between "this isn't great" and "there has to be a better way."

There are a handful of common things we see B2B software teams wanting to improve about their integration strategies. This blog series explores the most common integration-related goals and how an embedded integration platform like Prismatic can help.

In the previous post, we looked at how Prismatic can help you speed up integrations to achieve faster customer onboarding. This week, we'll look at the goal of reducing the integration workload on engineering teams.

Let's dig into why integrations take so much engineering effort and how Prismatic can help you change that.

Integrations take a ton of engineering time

If you're like most B2B software 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 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 making sure it's stable and secure. Finding ways to test integrations and implement logging. Managing customer-specific configuration. Troubleshooting and fixing issues that come up in production.

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

Here's why: most customer-facing teams lack the tools they need to do the parts of integration work that would otherwise fall in their realm.

When it comes to 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:

• Answering questions: Many customer-facing teams don't have the resources to easily answer even basic questions about integrations like “Is there an integration to Acme Scheduling? Is it one-way or two-way? What data gets passed?”
• 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 setup screen. Instead, they often have to gather credentials and config info from customers and pass it to engineering teams to do the actual setup. And that often 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 some credentials changed or needs to upgrade to a new version of an integration, support has to get engineering involved. Cue more back-and-forth.

The result is that engineering 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 pops up unscheduled, so even more time gets lost to context switching.

Most customer-facing teams lack the tools they need to do the parts of integration work that would otherwise fall in their realm.

The impact on core product development

You can see why integration work ends up consuming so much engineering time, which is one of a B2B software company's most precious resources.

And here's the biggest problem – that reduces capacity for core product development.

For SaaS 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. 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 huge percentage of your dev capacity – often upwards of 50% – on integration work.

That doesn't leave much time for the kind of core product innovation that keeps your offering competitive.

Prismatic reduces the integration workload on engineering

It's easy to see why B2B software companies so badly want to reduce the integration workload on their engineering teams.

That's where Prismatic comes in.

Prismatic is an embedded integration platform that was 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 engineering teams in two big ways. First, it empowers non-developers to take on far more of the integration workload than ever before. Then, it provides a purpose-built infrastructure so that your engineers don't have to spend time building and maintaining integration infrastructure.

Let's look first at how Prismatic empowers non-engineering teams.

Non-developers build integrations in a tailored low-code designer

First, Prismatic enables your non-developers to build integrations.

With Prismatic, non-dev team members create integrations by assembling components in an intuitive low-code designer. Prismatic provides built-in components that handle the vast majority of the work in your integrations: triggers, logic, data transformation, connecting to apps and services, and so on.

Auth is handled, versioning is handled, and a testing framework is built right in. Integrations built in Prismatic are reusable, so they 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 software company if you can tailor it for your product and industry, and that's where your engineering team comes in. Prismatic's custom component SDK makes it easy for your developers to write custom components that extend the platform to work for you.

For example, if you built project management software for rocket companies, your devs would write components that convert fuel between pounds and gallons, provide API connectors to other rocket software, and so on. Custom components are reusable, so your devs build them once and then integration builders can drop them into any integration as needed.

With this approach, developers only need to be involved in the part of building integrations 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 right? With Prismatic, non-developers can do all of those things while devs stay focused on core product work.

Customers and customer-facing teams deploy and support integrations

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

As I 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.

That makes it extremely straightforward to set config options, enter any needed credentials, and turn it on! Customer-facing team members like onboarding, services, or support teams can do this completely independently, without needing to involve developers at all.

Prismatic's management environment also provides all the tools and resources that customer-facing teams need to provide high-quality integration support.

For starters, Prismatic acts as an accessible, centralized repository for integration info, so customer-facing teams can answer customer questions without consulting developers. 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 like design specifications, troubleshooting steps – whatever your teams need. They can easily see which customers have which integrations enabled, how they're configured, when they last ran, if any errors have occurred, and so on.

Configurable monitoring and alerting notifies the appropriate teams 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 common needs like updating an outdated credential, tweaking a configuration, or upgrading to a newer version of an integration.

Putting all of these tools in the hands of your customer-facing teams greatly reduces the number of times engineering teams need to get involved with integration support.

You can even embed a white-labeled customer integration experience within your product to enable customer self-service. Customers can use an integration marketplace, configure their own integrations, and stay on top of their own integrations using Prismatic's logging and alerting. All of this makes your integrations feel like a seamless, first-class part of your product.

Enabling customer self-service in this way reduces the integration workload not just for your engineering team but for your organization as a whole.

Offload infrastructure work

Prismatic also 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 extremely time-consuming.

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

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

In summary

Prismatic helps B2B software companies get back one of their most valuable resources: engineering capacity. Contact us for a personalized demo to learn more about how it can help your team.