What are Native Integrations?

What are Native Integrations?

Native integrations are product features that connect your product with an external platform.

1. When you’re using Zoom, and a Zoom meeting is automatically added to your Google Calendar, Zoom has a native integration with Google Calendar.

2. When you’re using Notion, and Notion AI can search your Slack messages, Notion has a native integration with Slack.

3. When you’re using Cursor, and you mention “@Cursor” in Linear to trigger a Cursor agent to work on a PR, Cursor has a native integration with Linear.

Tools like Zapier and n8n allow end-users to build “integrations” between your product and a 3rd-party platform like Google Calendar, Slack, and Linear. But what makes an integration native is that your end-users don’t need to build integrations outside of your application. Your users no longer need to setup, maintain, and debug their own Zapier workflows. Instead, your users can rely on your integration logic that your product and engineering team control.

With native integrations, your users can connect a 3rd-party from within your application, enable any functionality that your engineering team has defined, and your application can start working with your users’ integration data!

Now that you know what a native integration is, we’ll cover the benefits of native integrations and how to start building your own native integrations.

Why Do You Need Native Integrations?

From the examples with Zoom, Notion, and Cursor, you can imagine how native integrations improve your product experience. Being more specific about these improvements, native integrations unlock use cases for your product, build product stickiness, and open buying and upsell opportunities.

Unlocked Use Cases

There’s a spectrum of use cases that native integrations can solve for. These use cases can span from simple CRUD operations that create a new record in your users’ CRM all the way to ingesting all of your users’ data for RAG.

Your product will undoubtedly have its own unique integration use cases. However, here are a few of the top native integration use cases for AI products that we’ve seen:

1. RAG from connected data sources

2. Agent tools that act on integrated platforms

3. AI workflows with 3rd-party action steps

4. Automated agents that have 3rd-party tools, RAG with 3rd-party context, and are triggered by 3rd-party events

Read more about these use cases in detail in our deep dive on integration use cases. We’ve also published an integrations report with case studies and market adoption statistics.

Stickier Product

When a SaaS product has native integrations, it becomes a part of your users’ software ecosystem. Using a product like Copy.ai (an AI GTM platform for sales, marketing, and GTM operations) as an example. Their product automates prospecting and enriches CRM data with their native Salesforce and HubSpot integrations.

Copy.ai’s native integrations include Salesforce and HubSpot webhooks that trigger Copy.ai workflows or Copy.ai agents to perform research in their platform. After the research is complete, forward that research data to an integrated messaging platform like Teams.

Copy.ai users become accustomed to the time saved from Copy.ai’s native integrations. This added value makes Copy.ai a stickier product that’s ingrained in their users’ workflows.

New Upmarket and Upsell Opportunities

With the additional value that native integrations bring, your GTM team can explore new opportunities upmarket and upsell to your existing customers.

Buyers upmarket expect SaaS integrations from the products they use. They expect data to be consistent across their SaaS products, making native integrations a must-have if your product works alongside your users’ other platforms.

Take a SaaS product like Calendly. A scheduling SaaS tool is expected to work with related platforms like Google Calendar and Zoom. Otherwise, Calendly users would need to create their own Google Calendar events and send their own Zoom invites. These native integrations save their users time, and not to mention, provide a better experience.

While some people may say these native integration features are a “nice to have,” these integration features can mean the difference between a won and lost deal, or thousands of dollars of recurring revenue.

How to Build Native Integrations

Paragon is an integration infrastructure platform that helps B2B companies build native integrations. Our customers can build native integrations faster and more reliably on our platform. Working with different APIs, there are specific challenges for each one as their APIs, authentication, rate limits are inconsistent with one another. Paragon handles these API challenges and provides abstractions like Actions and Syncs to make integration provider APIs more developer friendly.

Rather than go over the tradeoffs of building native integrations in-house versus buying an integrations platform - you can read that discussion in this build vs buy comparison. In the meantime, let’s go over what each developer experience looks like.

How to Build Native Integrations In-House

The first step to building native integration in-house is researching how the integration provider’s API works - specifically, what APIs you need for data operations and how to authenticate to that API.

Reading the integration provider’s API docs is the best place to start. Take note of all the CRUD endpoints you need to retrieve, create, update, and delete data. Some APIs and docs are more developer-friendly than others. Where a provider like Dropbox may have easy-to-use APIs, a provider like Notion may require recursion and multiple API calls to perform simple actions like getting page contents.

After researching API endpoints, you’ll want to take note of the scopes that each of these endpoints needs. The scopes are crucial for authenticating to the integration provider’s API so you can call the API on behalf of your users.

Most providers will use the OAuth protocol, where you will need to take note of the authorize and token endpoints, and configure your redirect_uri. In the authorize call, make sure to include the scopes from your API research!

Once you’ve set up your OAuth flow, the last step is storing the user tokens that the 3rd-party API provides. To give your users the best native integration experience, you don’t want them to have to constantly re-authenticate into their integrations. They should be able to set it and forget it.

To persist the connection between your app and an integration provider, you will need to store your users’ refresh tokens and ensure that access tokens are always fresh. If tokens are invalid, you won’t be able to call the 3rd-party APIs needed for your native integration’s functionality.

In summary, to build native integrations in-house

1. Research the APIs needed to get, create, update, and delete data for the use case you have in mind

2. Build out the OAuth process within your app, using the integration provider’s authorize and token endpoints - make sure you’re requesting the right scopes

3. Store your users’ access tokens to send authorized APIs and refresh tokens to retrieve fresh access tokens

Each of these steps takes hours to days depending on the ease-of-use of the integration provider’s API. Each integration provider has different OAuth requirements, rate limits, webhook implementations, and different API versions. These challenges are what integration infrastructure platforms solve for. Bringing us to our next section:

How to Build Native Integrations on an Integration Infrastructure Platform

Reading through the in-house process, you may have noticed that there’s quite a bit of work to build just one native integration. Your product will probably need a handful more to cover an integration category - i.e. for CRMs, you’ll want to cover at least Salesforce, HubSpot, and Microsoft Dyanamics.

When we say that a platform like Paragon helps users build native integrations faster and more reliably, here’s how we do it.

Paragon has 150+ pre-built connectors with the correct authorize , token , and redirect configurations. Our users can embed these connectors with our SDK - one SDK call brings up the OAuth flow for any of your native integrations.

Once connected, there are a few methods you can use to retrieve, create, update, and delete integration data. You can use ActionKit, an API with 750+ pre-built actions across our integration catalog. These actions abstract the 3rd-party API calls for most common operations users need. For those difficult-to-use APIs like Notion’s, we provide Actions like NOTION_UPDATE_PAGE_WITH_MARKDOWN so you can get, create, update, and delete data with less API research.

await fetch(`https://actionkit.useparagon.com/projects/${PARAGON_PROJECT}/actions`, {
	method: "POST",
	headers: {
		"Authorization": `Bearer ${paragonToken}`
	},
	body: JSON.stringify({
		action: "NOTION_UPDATE_PAGE_WITH_MARKDOWN",
		parameters: {
			pageId: selectedPageId,
			markdownContent: editor.getMarkdown(),
			replaceExisting: true,
		}
	}),
});

Another abstraction you can build on top of is Managed Sync, a sync service that provides your application access to all of your users’ data across an integration category like file storage, CRMs, and ticketing. Paragon customers use Managed Sync for use cases like RAG ingestion and analytics, so they can focus on building these features without worrying about API endpoints to retrieve data or webhooks to keep data up to date.

Not only do pre-built connectors, actions, and syncs make native integration development faster, but an integration infrastructure platform also makes your integrations more reliable. Paragon’s team will take care of integration API nuances like rate limits, token refreshes, and breaking API changes.

There are plenty of other benefits Paragon offers. Peruse our docs and website to learn more about Paragon’s monitoring, hosting, security, and other important features for building enterprise SaaS.

Wrapping Up

Native integrations aren’t just a “nice to have” for SaaS products. They are value adds that allow your team to unlock use cases, create a stickier product, and drive revenue.

Building these native integrations in-house vs with a platform like Paragon is a decision that has tradeoffs. If you’re considering building native integrations with a platform, try Paragon on a free trial or talk with our team. We’d be happy to help you start building your native integration strategy.

Whether your building in-house or with Paragon, just prioritizing native integrations is a step toward delivering seamless experiences your users deserve.