Setting up two-way syncs between databases, data warehouses, and spreadsheet tools like Airtable and G Sheets is a very powerful feature. Here we look at how you can do that using Stacker and Bracket.  

For growing teams, it’s crucial to have clear visibility on your company’s data. Whether you’re trying to tighten your sales funnel, respond quickly to user requests, or fulfil customer orders, the first step is always making sure the right people have access to the right data. 

But there are two hurdles to overcome: first, in a world where engineering resources are limited, there’s usually very little time to build internal data tools from scratch. Second, data often gets siloed in places off-limits to the non-technical team members who need it to do their job. 

Using no-code tools can help

By leveraging Stacker’s simple, no-code internal tools builder along with Bracket’s fast two-way syncs between databases and spreadsheet tools like Airtable and Google Sheets, you can get the right data flowing between non-technical teammates and your database with just a few minutes of setup. Plus, by empowering people to build and maintain their own internal tools, you’ll save days of engineering time. Let’s dig in.

What is internal tooling?

There are a few different ways to make data visible

When data engineers need to get data in front of the right team, they have a few options:

• Exporting data to an easy-to-read format, like CSV, either manually or on a scheduled basis
• Building a BI dashboard
• Building an internal tool, either from scratch or through software like Stacker

Internal tools are the best option when users need to write, not just read, data

The first and second options can work just fine for basic data reporting. For example, if you run a car rental business, it’s helpful to see how many cars you have available at any given time. But what if you also need to assign cars to users? In other words, what happens when you need to make edits back to the data? This is where internal tooling shines. 

Simply put, internal tools are any data tools that allow your teammates to read & write your company’s data in a controlled, customized atmosphere. The best internal tools are simple, easy-to-use, and fast.

You could build an internal tool for just about any use case involving data: CRMs, ticketing systems, inventory management systems, customer success tracking, and admin panels could all be built as internal tools.

How can I build internal tools?

Generally, there are two ways to build internal tools: from scratch, or through third-party software. Below, we dive into the pros and cons of each.

Building from scratch

When does it make sense to build from scratch?

If you have ample engineering bandwidth, there are benefits to building an internal tool from scratch. Going this route generally gives your engineering team maximum flexibility and control over the tech stack used and features delivered - for example, you can use custom Javascript code to create the exact internal tool needed. However, building from scratch can also lead to weeks or months of diverted engineering time, lots of back-and-forth between engineering and the end users of the tool, and hours lost on long-run maintenance. 

In general, building from scratch is recommended if (1) your internal tool use case is exceedingly bespoke, or (2) you have plenty of engineering bandwidth.

Pros:

1. Most flexible feature set: only limited by the UI components in existing libraries, meaning customization is near infinite
2. Greatest control over tech stack: engineering commands the entire process

Cons:

1. Requires much more development time to understand use case, design UI, get feedback, and implement the entire stack - the process can take months
2. Requires engineers to maintain the entire stack over time, including the database, data transformations, and UI

‍

Building with third-party software

When does it make sense to use third-party software?

If you need to move fast, or don’t want to divert weeks of engineering work to internal tooling, using third-party software is often a good way to go. Third-party tools, like Retool and Stacker, give you a simple drag-and-drop interface with pre-built components. Not only are these components easy to work with out of the box, but by working with well-established third-party software, you get the benefit of online communities who can help unblock your engineering team.

There’s one final and important benefit of using no-code tool builders like Stacker: by enabling your non-technical teammates to build their own internal tools, you allow engineering to focus its time on technical tasks, like maintaining the database and setting up data pipelines, while empowering the end user of the tool to build exactly what he or she needs. No need for endless back-and-forth design meetings!

Pros:

1. Move much faster with pre-built components, which are usually sufficient for key features
2. Leverage existing online communities and documentation for support
3. Save tons of engineering time by empowering your non-technical teammates to build their own internal tools to fit their use case, allowing engineers to focus on database and pipeline management

Cons

1. For highly-specialised use cases, pre-built components might not be sufficient

How can I connect an internal tool to my database?

Databases are mission-critical

Many companies store their mission-critical data in SQL databases, like Postgres or MySQL, or data warehouses, like Snowflake or BigQuery. While these services are excellent for big data storage and scalability, access to them is usually not company-wide. This is for good reason - you don’t want the intern accidentally deleting your entire production database. Database management - data security, access control, is one of the primary functions of a data engineer.

Building a UI is only half the battle

But this leads to an age-old problem: how to give non-technical users the ability to read and write this data when necessary? Maybe you need your inventory managers to be able to mark damaged inventory, or your vendor management team to accept or reject vendors. Building the UI for an internal tool is only half the battle; you also need to connect the tool to the database.

Setting up data syncs is essential too

By using a data syncing tool like Bracket, you can set up real-time two-way syncs between SQL databases, like Postgres, and spreadsheet tools, like Airtable or Google Sheets. You can even use Bracket to spin up Airtable tables from scratch using the data already in your database, decide which fields you want to sync, and get visibility on records changed over time. You can also set policies on how deletes are handled, making sure your database is kept safe. 

Once the data is syncing with Airtable, the engineering job is done: you can hand the Airtable to your non-technical teammates, who can then design custom internal tools on top of the Airtable using Stacker. 

Why split up the task of building internal tools?

Data engineers should focus on their core function

The job of a data engineer is to manage and scale databases, make sure data is clean, and maintain data pipelines. Yet too often data engineers are called upon to design and implement internal tools, projects that can require weeks of stakeholder alignment, design interviews, and testing. Not only do these long project timelines distract the engineering team from its core functions, but they also frustrate the stakeholder teams that need the internal tool to do their jobs. 

This is why it makes sense to split up the task of building an internal tool. Data engineers should be responsible for data management: making sure that data is clean, syncing to a user-friendly tool, and isn’t at risk of being deleted or overwritten when it shouldn’t be. But non-technical teams should be responsible for designing and building the internal tool for their specific use cases - after all, they know better than anybody how to optimize their user experience.

The quickest way to build

By leveraging Bracket’s engineer-friendly data syncs and Stacker’s user-friendly no-code app builder, you’ll achieve a win-win. Not only can this structure speed development up 10x, but it will make everybody happier: data engineers can focus on their core function, and nontechnical teams can build the exact tooling they need to do their job well. To find out more about what Bracket can do, speak to its founder Ian Yanusko.