We Gave Our Customers an API

Here's a scenario from our archive of prospect and customer conversations:

When we built our app, we were super focused on the UX because it's a big part of what differentiates us from our competitors. However, integrations were not top-of-mind. So, when customers started telling us they loved our app but we needed integrations, we built them an API. Now, they have integrations, but the UX is all over the place, and we're feeling the pain.

Building an API for one's customers was very popular a few years ago. And it's still the answer some folks use to solve (or dodge) the integration question. But it's not a long-term solution.

So, what is the root problem? The root problem is an unnecessarily narrow view of what makes a product coupled with an irregular UX.

The solution? We'll get to that. But first, what other issues are likely to accompany this scenario?

Related issues

These are not the only additional issues that might arise with this scenario, but they are some of the most concerning.

Reactive approach to integrations

There are always issues when a SaaS team reacts to integration needs rather than proactively managing them. In this case, the team implemented what it thought was a reasonable solution. However, this reactive approach means that the team doesn't own the integrations, but rather the integrations own them. And they'll continue to react rather than get ahead of things until something changes.

This solution is technically functional but doesn't properly support the user experience. Yes, your customers have integrations, but those integrations don't match their expectations for the product. The original product was well thought out and strongly emphasized the UX. But, the integrations were an afterthought rather than being carefully designed.

In addition, the reactive approach to building the API (and having the customers each create their own integrations) will likely lead to technical shortcuts and inconsistencies for the SaaS team and customers. This technical debt will need to be addressed at some point.

Slower integration adoption

When the disconnect between the product and its integrations is this great, it will hurt integration adoption. This is true for the following reasons:

• Customers allocate a certain amount of time for onboarding, often expecting that integrations will be part of that onboarding process. If they must be addressed separately, that's going to extend the onboarding time and make the onboarding processing more difficult to plan.
• If the customer is building the integrations, the customers' devs need to ramp up and become familiar with the API and documentation. Then, they need to figure out what support they are provided and what they must do independently. This adds more time for a team that wasn't planning to build these integrations anyway.
• If the integration UX is poor, customers will hesitate to use them, even if the underlying functionality is valuable. This limits the product's potential.

Greater customer frustration, likelihood to churn

If the team that built the original product didn't have the resources to build the integrations, how likely is it that each customer will have the resources necessary to create the integrations themselves?

The "UX is all over the place" likely means customers are dealing with different interfaces, workflows, and levels of usability, depending on the integration. This leads to frustration, confusion, and the idea that there must be a better way to handle integrations.

While customers initially loved the app for its UX, the inconsistent experience with integrations might destroy that positive. When integrations feel clunky or disjointed compared to the core product, it frustrates users and increases churn as customers seek more streamlined, consistent solutions from competitors.

Missed opportunity for revenue

For some prospects, the idea of building their own integrations with the product means that they won't examine the product any further, even if it has the best UX for any product in that market sector. Many customers have had abysmal experiences building their own integrations and prefer to walk away before dealing with that mess again.

And even those customers who are willing to build their own integrations aren't going to pay much (if anything) for the privilege. If the team had provided integrations with its core product, it could charge more for the value provided. Unfortunately, competitors with better integration solutions can charge more for delivering greater value to their customers.

By not actively managing integrations, the team may miss opportunities to innovate and differentiate its product from others in the market. As a result, the company may find that the wonderful UX the product shipped with is no longer sufficient to give them an edge as competitors meet and exceed that UX because they (the competitors) can provide essential integrations out-of-the-box.

Don't stay where you are

If this scenario and its related issues match how things are going for your integrations, we have some good news: you don't need to stay where you are.

Remember this scenario's underlying problem? "An unnecessarily narrow view of what makes a product coupled with an irregular UX."

To address this, we bring you Prismatic – an embedded iPaaS that allows you to build first-class integrations to extend your product while maintaining the UX your customers expect. Here's how it helps.

Proactive approach to integrations

Prismatic allows you to proactively handle your integrations by simplifying and streamlining the integration process.

Start with standard pre-built connectors and add the ability to create custom connectors on top of that. Couple this with a low-code integration designer and the functionality for your devs to build integrations in code and you'll see a real-time increase in efficiency.

Everything necessary for the integration lifecycle is available from the platform, allowing your team to build, deploy, and manage integrations at scale. Whether a team member is adjusting the config for a new integration, troubleshooting an existing integration, or simply staying on top of alerts and logs to ensure everything is running smoothly, Prismatic provides all the tools necessary to manage those integrations proactively.

Faster integration adoption

Prismatic lets you customize a white-label integration marketplace (or build one complete custom with our SDK) to list your integrations. Within the marketplace, you can enable customers to self-activate, allowing them to select and run integrations without any assistance from customer support.

Meanwhile, on the back end, the platform handles everything from auth to error handling, allowing your integration team to focus on the integration details (how you'll transfer data from A to B) rather than the infrastructure. This will speed up your build and deploy times, allowing your team to move from a customer integration request to a completed integration in days or weeks (not months).

And, since the integrations are native to your product, there's no daylight between the integrations and the product. You can extend your product's UX seamlessly to its integrations.

Happy customers, sticky product

Prismatic enables you to have integrations ready at onboarding, enabling your customers to see value sooner and increasing your product stickiness. After onboarding, customers can activate, view, monitor, and even troubleshoot your integrations themselves via the provided UI.

When activating integrations is straightforward and feels like a natural part of your product (thanks to white-labeling), customers are more likely to adopt them. Each activated integration deepens a customer's reliance on your platform and embeds it further into its business ecosystem.

And, by offloading much of the integration infrastructure to Prismatic, your devs can focus more resources on your core product. As a result, customers receive a dual benefit from better, more useful integrations and an improved core product, increasing customer satisfaction.

More revenue opportunities

Prismatic drives additional revenue opportunities in the following areas:

• Opportunities you wouldn't close without having integrations. For some customers, a lack of integrations means they'll keep searching. But if you have integrations, you'll be more attractive than competitors without them.
• Integrations you'll already have available for prospects. These are the productized integrations that are immediately available via your integration marketplace. Prospects can onboard with your product and get their standard integrations at the same time.
• New integrations you can build in a few days or weeks (not months). As your customers increase, so will their need for integrations. So, there will always be more integration requests coming at you. But with an embedded iPaaS, you can quickly act on these requests to build the integrations.
• Upsell opportunities for existing customers who need productized integrations, bespoke integrations (that you could build for them), or even one-off, custom integrations that they could build themselves using Prismatic's embedded workflow builder. In fact, if your customers would benefit from the flexibility that comes with an API while still keeping a consistent integration UX, the embedded workflow builder may be just the ticket.

What next?

Prismatic lets you provide customers with powerful integrations that look and feel like your product. This ensures that the UX is consistent with the product and its integrations rather than being hit or miss depending on how customers write integrations to your API.

Schedule a demo, and let us show you how including native integrations with your product can provide benefits that range from decreased time-to-market to customer satisfaction and revenue opportunities.