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?
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.
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:
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:
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:
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 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.