Case Study: Flatfile

Flatfile Logo

Overview

  • Industry: B2B SaaS, Data management
  • Team Size: 60
  • Airplane Usage: 200+ runs / week

Flatfile provides software that helps businesses automate the way they onboard customer data where their customers ingest, normalize, and validate data from third parties to make it instantly usable in their systems.

In March of 2021, they raised $35M in Series A funding led by Scale Venture Partners and have been adopted by businesses including Square, HubSpot, and Coupa. They use Airplane as a solution to a number of internal tooling gaps at their company.

Increasing technical demands led to bottlenecks and customer latency

As a SaaS company, customers frequently need to contact Flatfile to take care of one-off operations that aren't possible to do in the product directly. Examples include:

  • Archiving a workspace
  • Changing a team owner
  • Removing a user from a team
  • Restoring or unarchiving a workspace

Before Airplane, developers would have to go directly into the production DB and run SQL queries to carry out these operations. These operations were locked down to a handful of engineers due to the dangers that can come with broader prod access like accidental deletions of data and unintentional config changes.

At first, it wasn't a huge issue for the few engineers who had access to the prod DB to get involved on a one-off basis for these infrequent requests. As Flatfile grew, however, the number of requests that required people to manually run queries against prod continued to increase. The number of requests related to account administration and user management soared as they took on new customers.

Additionally, without a source of truth or centralized knowledge base, developers had to constantly re-create and remember queries for common operations.

Engineers were also facing greater technical demands on the product front. As a result, they were forced to make tradeoffs between investing in the core product and helping build internal tools. Being pulled in to help with frequent requests resulted in constant interruptions. Even with a customer success team, it wasn't feasible for everyone to learn the level of SQL required to execute these operations safely nor did they want to extend write access to prod beyond a handful of engineers.

This situation also led to significant bottlenecks and latency in customer response times. Requests to engineering would go 2-3 days without answer because they were blocked on a small handful of engineers who were swamped with the demands of a rapidly growing product.

Airplane as the solution

Things changed when Flatfile adopted Airplane. Nate Ferrero, head of R&D, started using Airplane to automate some of the more one-off-but-tedious requests from customers asking to "unarchive a workspace" or "update a user name." Within a few hours, he quickly built out a series of tasks to handle these requests. Quickly, Airplane became Flatfile's primary solution to internal tooling.

"Before Airplane, a few devs had become the bottleneck to the whole company because they were the only ones with write access to prod. Airplane expands the number of people who have the ability to solve issues themselves, which helps us grow more quickly."

Airplane solves a number of problems for Flatfile:

  • Provides safe, democratized access: Enables non-engineers to safely run operations using Airplane tasks that were previously limited to a just a handful of developers. Flatfile can monitor who does what and when via audit logs and also set up granular permissions and approval flows.
  • Minimizes interruptions: Limits the number of interruptions that developers experience so they can focus on building core product. Runs can be requested and approved directly from Slack.
  • Automates manual tasks: Eliminates the time spent on running recurring operations and managing infra for internal tools. Airplane automates many of Flatfile's manual tasks like changing a team's owner, pulling a license based on team ID, and looking up a user ID from an email.
  • Provides a knowledge store for operations: Prior to Airplane, it was time-consuming for developers to rewrite the same queries or remember the right queries for different operations. Airplane solves the problem of knowledge sharing by serving as a source of truth for operations.

Use Cases

There are a few key ways in which Airplane has been impactful at Flatfile:

  • Account administration and user management operations: The majority of Flatfile's operations center around account admin and user ops. These are things like adding a user to a team, changing a team's owner, and changing a user's name. Before Airplane, Flatfile's engineers would get involved every time by writing queries against the DB or using tools like Postman to hit internal APIs. Now, they use Airplane to take SQL queries, deploy those in minutes, and give the support team access to action them independently.
  • Debugging: Airplane gives Flatfile's engineering team the ability to debug information from prod without giving everyone direct access to the DB. They frequently run Airplane tasks that look up object metadata related to issue they're trying to diagnose and debug. Having constrained, parameterized tasks in Airplane is much safer than giving general DB read access to everyone on the team. With Airplane, engineers read from the prod DB, diagnose the issue, and then write actions to make updates using approval flows.
  • Lighweight Feature Flags: When rolling out new features, Flatfile's team often wants to specify which features should be turned on and off and who can have access to them. Airplane lets Flatfile test and iterate on new features before hard rollouts without having to manually make config changes, enabling them to speed up the product launch process. Additionally, feature flagging helps distinguish which accounts do or do not have access to paid enterprise features.
  • Sensitive operations: Operations like archiving a workspace, deleting a license, and removing/deleting users tend to be sensitive in nature because they involve deleting data. Rather than sink time into building bespoke approval workflows and micromanaging individual permissions, Flatfile engineers handle these in Airplane using group permissions and approval flows.

Using Airplane to Accelerate Product

Flatfile used Airplane to accelerate the timeline for the launch of one of their newest products: Data Hooks. Data Hooks re-formats, validates, and corrects data automatically during import and can be used for things like automatically reformatting area codes or country codes, removing special characters, and validating emails against external data.

Prior to rolling out Data Hooks, Flatfile was running beta versions of the feature in a VM sandbox. They wanted to avoid giving customers direct access to the VM sandbox until the feature was in production but still wanted a way to test and iterate on the feature quickly.

Using Airplane, Flatfile was able to grant their customer success team access to edit Data Hooks in the system on behalf of customers weeks before the production solution was ready.

Rather than building a whole new class of access controls and permission groups into the core product, with Airplane, Flatfile was able to unblock prod usage of the feature by beta testers before rolling it out more broadly. This massively impacted the rate at which they implemented feature requests and accelerated the timeline for the product rollout.

Today, Flatfile's team executes hundreds of runs with over 20 unique tasks in Airplane every week and usage is continuing to grow. "If Airplane wasn't there to let us lock down prod DB access and still give our teams the ability to carry out common operations, a few people would become the bottleneck for the whole company. Airplane is the reason we're able to move quickly."

Sign Up
go to home