Close customers faster by prototyping long-tail integrations

Imagine this scenario: you’re on a sales call with a prospective customer who’s very interested in buying your product. Everything’s going well until they mention a critical detail: they need a Pipedrive CRM integration in order to get value of your product. Pipedrive is on your roadmap, but you’ve got a bunch of other competing product priorities. Yet the customer wants to see how it works before they sign the contract. What do you do?

The long-tail integrations dilemma

It’s a classic chicken-or-egg dilemma. User-facing integrations are crucial to getting value from your product, often acting as deal clinchers or premium upsell triggers. However, they're also customer-specific, warranting prioritization only when there's sufficient demand.

This is particularly true for "long-tail" integrations. Companies usually prioritize integrations for common platforms like HubSpot and Salesforce but postpone integrations with smaller players like Pipedrive, Zoho, or Copper. Long-tail integrations are deprioritized until customer demand reaches a tipping point or a large contract requires it.

While it's the right product strategy for startups with limited resources, it also means deals will get stalled due to missing integration support. While delaying individual deals might not seem significant, the cumulative revenue potential of deals requiring long-tail integrations can be substantial.

Prototyping: the way out

We’ve seen customers successfully navigate this dilemma through prototyping. Prototypes are bare-minimum, functioning integrations that can be used for sales demos. While they're not production-ready and could be missing features, prototypes offer several benefits:

• Faster close times - by demoing your integration, you can close customers faster and mitigate the risk of losing them to competitors by making them wait for weeks or months.
• More efficient resource deployment - avoid committing expensive engineering resources and time until customers are committed to using and (paying for) your product. We’ve see companies spend time on an integration for a customer, only for the deal to fall through.
• Better product scoping - by getting early customer feedback on what the final product will look like and surfacing any issues early on, prototyping sharpens the product requirements. This can product spec and cut significant scope once a customer is able to visually see the functionality.

Building a user-facing integration prototype

When prototyping, you should optimize for speed. Focus on what a customer needs to see in a demo, and strip out the rest.

For example, a simple prototype for a user-facing CRM integration might include connecting to a CRM instance and being able to view CRM records in your app. There are several classes of things you can leave out of a prototype to save time:

• Performance - set up a test instance with a few dozen records, so you can avoid backend optimizations and scaling considerations.
• Error handling - show the "golden path" on sample data you've already tested on, so you can avoid edge cases.
• Features - implement only crucial features that prove the integration's value, that you will show in a demo.
• Polish - the prototype doesn't need to be pixel-perfect. Focus on functionality.

From prototype to production-ready

After you’ve signed your contract, you’ll need to go back and productionize the integration to onboard your customer. Most of the time your prototype will look nothing like the production version of the integration:

• You might have made technical choices in your prototype that made sense for speed but won’t scale for production.
• You might need to refactor a bunch of code, create new abstractions, or standardize interfaces with other integrations that already exist in your product.
• You might even have new product requirements based on customer feedback.

It's usually faster and cleaner to just start from scratch. While this might seem wasteful, it's usually the right tradeoff, especially for early-stage startups prioritizing customer commitments and rapid product iteration.

Prototyping with Supaglue

Prototyping helps companies close customers faster and deploy valuable engineering resources more efficiently. However, the ROI becomes harder to justify if you need to prototype not one, but many long-tail integrations. Maintaining prototypes as your product evolves can become a significant tax, and you'll have to redo the productionization transition multiple times. Many companies don’t want to deal with this additional surface area.

If this resonates, you can try out Supaglue. Supaglue is a developer platform for building user-facing integrations. It built and continuously maintains the long-tail of integrations so you don’t have to. Because Supaglue takes care of things like authentication, syncing data, and normalizing schemas across different APIs, you can create prototypes in an sandbox environment in hours. Best of all, the platform will scale when you’re ready to onboard a customer, so you don’t need to spend time rebuilding your integration to be production-ready.

Check out our docs to get started or reach out on Slack with any questions.

‍