The Developer’s Case for Building Native Integrations

Integrations and automations are crucial to working faster with today’s best software. But all integrations are not built equally. Here’s why the most crucial integrations need to be built into software—based on what we’ve learned while building Fillout.

Do not index
Do not index
Hide CTA
Hide CTA
Hide cover
Hide cover
A form app is rather useless without integrations. As is most software. An app could have a world-class interface and never-before-seen features, but without an easy way to pull data in from one app then export it to another, the software would be an island unto itself.
Integration platforms like Make and Zapier, along with more manual API and Webhook integrations that users connect to their in-house apps, let people replace copy and paste and get computers to do more for them. That’s a win.
But it’s also not enough. While building our form and survey app, Fillout, we found, along the way, that third-party integrations can't entirely replace deeper, native integrations. They’re what make the difference between you needing to look up data mid-task, and just getting the job done.
Here’s the distinctions we’ve learned—and why the software you use (or build) needs both native integrations and automation platforms to make you the most productive.

The Case for Integrations

The earliest software was designed to be integrated.
“Do one thing well,” advised the software development philosophy has shaped software from the beginning. It also recommended that all software “speak the same language.” One app’s output would be another another’s input.
Input and output. That’s all computers do. They take some input data, process it, then output it.
Web apps—software like Slack, Salesforce, Shopify, and the hundreds of other tools that the world runs on today—in many ways work that way today. They’re often built to do one thing well—team chat, CRM, eCommerce, for those three–then outsource every other task via their API.
So when you get a new sale in your Shopify store, the Shopify API posts data about that order, details that could be imported as a new contact in your Salesforce or Airtable CRM or as a message to your team in Slack. The most common way to do that is with an automation platform, software like Zapier, IFTTT, Make or Nango’s native integration builder, that sit between your web apps and translate incompatible inputs/outputs so they play nicely across platforms.
That simple concept has helped automate more computer work than almost anything else. Anytime you’re not copying and pasting text between apps, or exporting CSV files and importing them again, odds are an integration platform is to thank. And it’s incredible.

Native integrations versus 3rd party integrations

A Make automation can add new contacts every time a Fillout form is filled out
A Make automation can add new contacts every time a Fillout form is filled out
As a form and survey app, Fillout wouldn’t be nearly as useful without the thousands of software integrations our Zapier and Make integrations bring. There’s no way our team could build integrations for every app. Once we integrated with Make and Zapier, anyone could build forms to make Todoist, Asana, or Trello tasks, add new subscribers to MailChimp or ActiveCampaign, and so much more. For those and so many other jobs, all you need to do is send form submission data (the output) to another app (formatted as input). Rinse, repeat. That’s where third-party integrations are perfect. They don’t need to be that deep.
Input, output, which then becomes another program’s input … that works fine. What doesn’t work so great is if, in the middle of processing, you want to pull in data from a 3rd party tool. That’s where native integrations are the only way out.
Integration platforms live and die on mapped fields, where you tell Make or Zapier that your form’s Name field should be linked to the First Name field in your CRM. Rename something, or add a new form field, and your automation will break. Build in a search function to find, say, a Company to link to a contact, and if the name in the form is spelled even a bit different from that in the CRM, and the whole workflow grinds to a halt.
Then imagine a more advanced workflow. If you run a B2B sales operation, and you want to display different checkout options depending on whether it's a customer's first order or their 10th? That’s possible, if your data’s all in one place, in Shopify, say. But even the fanciest automated workflows can’t make that happen if your customer data is in one app, and your checkout flow’s in another.
A Fillout form’s Airtable integration can turn database fields into form fields, and pull in company details from a CRM
A Fillout form’s Airtable integration can turn database fields into form fields, and pull in company details from a CRM
When you’re directly interacting with the data that your business runs on, you need more control. That’s why at Fillout we prioritized deep, first-party integrations with our database partners, tools like Airtable, Notion, SmartSuite, Salesforce, and HubSpot (along with pure databases like MySQL and Postgres).
The first level of deeper integration came with our Google Sheets integration. Here, Fillout automatically creates a new spreadsheet and links it to your form. Add a new field, and Fillout adds a new column to your spreadsheet. That’d be possible with an automation platform—but honestly, it’d be easier to just open the spreadsheet and manually add the new column. Fillout saves you the trouble.
The next level came with database apps. With software like Airtable and Notion, Fillout turns your existing database fields into form fields. Instead of needing to select a plain text field, name it Email, then link it to your Airtable contact’s Email field, Fillout does all of that for you, possible thanks to its deep integration.
That’s handy enough. But databases work through linked data–and Fillout’s integrations work here, too. You can select a new contact’s company from a list—then use that company’s contact data, pulled from Airtable, to update field text or descriptions in real-time. It’s software inception.
Fillout can automatically pull data into your form, thanks to deep, native integrations
Fillout can automatically pull data into your form, thanks to deep, native integrations
And that lets you build what feels much more like a unique, handcrafted no-code app than any third-party integration platform could provide. You could have an integration platform search for a company by name and try to link it, but it’ll be error-prone as one person types “Acme” and the next types “Acme, Inc,” for instance, and there’s no way you could fill Acme’s details in the form without Fillout-style deep integration. That’s especially true with multiple-choice questions. If a single mapping is wrong, the whole record won’t get created. It’s here that the advantages of best-in-class, first-party integrations proved worth the investment.

Native integrations for work. 3rd party integrations for workflows.

We’d never build every possible integration Fillout needs as a product. But our experience with building our deepest integrations has informed how we think about building software.
It started with our experience in learning how not to build AI into software. At first, we threw a GPT integration into Fillout without enough thought for how it’d be used—and thus, it wasn’t used all that much. Only when we went back to the drawing board and figured out specific use cases for AI-powered forms—building forms faster with text input—did we land on something that our customers loved.
The same goes for integrations. We’re grateful for the thousands of Make and Zapier integrations—along with the one-off integrations users can build with Fillout’s Webhooks and email support. They’re how people can kick off workflows with Fillout, how you could send the team a Slack message and email a prospect and add a task to Asana, as soon as a form is filled out.
But for the things that are crucial for work, for the data that would actually make a difference while you’re working inside Fillout, we want to build the best native integrations possible. It’s not enough to send your data out, if you’ll have to manually look up stuff and link it together yourself. It’s worth having a native integration that can pull the data into your form, help you and your customers gather better data, faster, and then kick off the Rube Goldberg chain of workflows once the core work is done.
If you’re building software, build in integrations. Start with integration platforms—they’re the easiest way to level up your software quickly. Then think through the software that’s most crucial to your customers’ work in your software, and see how you could make that better with a native integration. Trust us: It’s worth the time and investment.
And if you’re buying software, think about the data you’d want to use while working in that app. Check that tool’s integrations, and see how deeply it works with your most crucial software. That might be a reason worth buying one app over another, if it’s deeply integrated enough that you’re pretty sure you won’t have to jump ship to the next shiny thing next month.
Image Credits: Header Photo by John Barkiple via Unsplash
Dominic Whyte

Written by

Dominic Whyte

Dominic is a co-founder at Fillout. He previously worked in engineering & product at Retool. Prior to Retool, he started Cheer (backed by Sequoia and acquired by Retool in 2020).