If you’ve ever had to wrangle a maze of marketing, sales, and BI tools—just to end up plugging it all into a spreadsheet—this article is for you.

We’ll go over the three core dashboards we built for all marketing and full-funnel metrics, why we chose to build our own, and how our marketing lead Kevin White (formerly of Segment, HackerOne and MemSQL) uses them.

Why our own dashboards vs. existing tools

With a background in marketing ops and driving demand, Kevin has had a front row view of how marketing tech stacks and data pipelines have evolved and expanded over the last decade.

What's most surprising? Most companies still struggle with a simple problem: aggregating, viewing, and acting on different data sources.

While the problem in the past may have been that the tools were not powerful enough or the data you needed didn’t exist, today we face a different issue: there are too many tools at your discretion. Your data sits in an endless assortment of ad platforms, marketing automation platforms, CRMs, payment processors, and data warehouses that are all good at a specific job—but leave you struggling to get a cohesive, comprehensive picture from 10 open tabs.

Retool solves this nicely, as we can pull in data from data warehouses, Stripe, Salesforce, Google Ads,Segment—really anything with an API—to build an interface custom to your business. And, much like great tools in the vein of Mixpanel or Amplitude, we make it pretty easy for everyone to have canonical company dashboards and replicate/customize them for their own needs.

What is unique about Retool, then? We treat analytics like a product: rather than a static view/dashboard, our marketing team has a veritable app to play with.

For example, for a product launch, we can use Retool like a BI tool to drill into the metrics—but also use it as a sign-up tracker, a goal-oriented dashboard, and a workflow manager (e.g., "when metric X hits Y, do this").

This also means we don’t have to limit ourselves to the structures defined by a BI tool. If anyone on the team wants to add a button, a workflow, or a deep-dive modal, Retool’s ability to say "Yes!" to deep and fast customization is what makes a difference when it comes to acting on the data.

Last but not the least: at Retool, we like drinking our own champagne. The more we use our own product, the better it gets, the more confidently we can speak about it, and the better we can market it.

Our main marketing dashboard: core metrics and visualizations

If you are wondering what a marketing dashboard should include, our main Retool marketing dashboard is a good start. Kevin’s goal was to have both a bird’s eye view of key marketing data so he can easily spot trends, and the ability to drill down into different data vectors over different time periods.

Kevin looks at this dash daily: it contains our core metrics, including those we use for reporting to the company and the board.

The dashboard essentially looks at different parts of the marketing funnel: leads, MQLs, and sign-ups.

Let’s zero in a bit.

The top two charts look at leads and MQLs by channel. You can set a date range, and cohort the data by different time period types (date, month, year). The charts are interactive: you can hover over any bar area to see actual numbers and your selected date range, and drill into any channel by checking the menu box on the right.

Having leads and MQLs chart side-by-side allows for a quick glance into conversion rate trends, both by channel and by time period:  

The next two charts provide a look into:

1. The composition of paid vs. organic leads, and
2. Traffic sessions by source type

This allows us to not only understand key metrics at a glance, but also correlate traffic (chart on the right) with leads (chart on the left).

SaaS marketing funnel: from landing page to sign-up—and cohorts too

While charts are useful for quick observation of trends, the three tables on our main marketing dashboard are focused on tracking the full marketing funnel, from visit to sign-up. In the first table, Kevin can see how weekly cohorts are converting:

Next come two tables for analyzing the marketing funnel by landing page and referrer channel. The beautiful thing about these charts? You can drill down into each individual row. For example, seeing how each use case page is performing—from traffic to sign-up page visits, to converting from sign-up page to actual signup—is super useful, and not just for the marketing team.

Supercharging Google Search Console

Google Search Console is a powerful tool, but it is somewhat lacking in data visualization. Jane Kelly, our head of growth, put together a dashboard that augments Google Search Console with some neat new views and visualizations.

The top part of the dashboard is a customizable chart for comparing different datasets: in our case, Kevin uses Dataset 1 to represent branded search (light blue), and Dataset 2 the non-branded (dark blue). Again, you can aggregate data by any time period. The chart also includes drop-down filters for page, country, and device.

In our case, the chart shows at a glance that our investments in non-branded organic search terms are starting to pay off.

Below this chart we put together a query (search term) table accompanied by a visualization that helps us see when a certain search term starts picking up in impressions, clicks, and the CTR rate—and when its overall position improves.

Further down the funnel

Kevin visits this Retool dashboard for insights into our full self-serve funnel by different vectors. It gives him the ability to, for example, show how pages with different landing page types and paths are converting visitors beyond sign-ups: to paid users, actions taken within the app, etc.

Once again, the ability to drill into full-funnel performance by channel is key.  

What’s next

Just as we were writing this article, our head of growth Jane Kelly pinged us with an update:  

What’s next will not just be driven by marketing “end-user” demand, but also produced in a self-serve fashion, with team members frequently creating their own apps, such as this content dashboard:

The idea, then, is not that Retool is the be-all-end-all tool for your marketing analytics, but that treating your analytics as an ever-changing, nimble product, rather than a static dashboard, has significant advantages.

Before Retool, our co-founders tried to build a Venmo competitor but failed to reach product-market fit.

While their first product didn't work out, they came away with an important lesson: great internal tooling can help startup founders fill early product gaps and speed up manual work. The only issue was that building these tools was too slow and repetitive. So they decided to build a better solution.

Today, Retool helps thousands of startups like Brex and DoorDash build custom internal tools without wasting time on redundant work. Retool helps early-stage teams operate fast without all the restrictions that come with spreadsheets, SaaS tools, or manual workarounds.

We believe great tooling can help startups focus on building better products. That's why we're excited to announce that Retool is now free for early-stage startups. Get your free credits now →

Introducing Retool for Startups

It's easy to solve less critical work with out-of-the-box tools. But what about the internal tools that are core to your business? We see a lot of technical founders and engineers spend a lot of time building (and rebuilding) the same tools:

• Tools that join product and Stripe data into a single customer view
• Tools that convert manual workflows into fully-featured apps for your team
• Tools that help non-technical teammates read and write to your database

But building from scratch can take weeks, and distracts your team from focusing on your core product.

Retool gives technical founders a head start. You can use pre-built UI components, database integrations, APIs, and advanced features (like access control) to create any CRUD app, dashboard, or tool you want. It enables your team to solve problems fast and get back to building your core product.

Retool for Startups gives early-stage startups up to 12 months of free access to the advanced features on our Startup and Pro plans (up to $1200 total value).

We also know that great internal tooling requires the right stack, so we've partnered with AWS, MongoDB, Segment, and more to give you powerful options at the best possible price—totaling over $160,000 in software discounts.

We first adopted Retool to build out our internal tools for customer success at neo.tax, but we soon discovered lots of other use cases for it: internal company-wide demos, quick product mock-ups, and ad-hoc data analysis.

We now consider Retool a core part of our software stack. Thanks to Retool’s startup credits, we can maximize our time on our most important company objectives. It’s an absolute win-win for everyone!

Firas Abuzaid, co-founder and CTO at neo.tax

Who counts as an early-stage startup?

Our early-stage discounts are available to startups that meet both of the following criteria:

• Launched less than 5 years ago
• Raised less than $10M in funding

Not sure if you qualify? Apply anyways. If you are affiliated with any of the venture funds or accelerators below, you can also reach out to them directly to receive an exclusive referral code for even more Retool credits on top of our standard deal:

• Sequoia Capital
• Techstars
• Antler
• Y Combinator

Don’t see your venture fund or accelerator? Tell them to apply to be a Retool Startup Partner here.

Get started

Don't let internal tooling be a roadblock in shipping your product. Use Retool to build every process and tool you need to grow faster.

Get your free credits now →

Solera Health is a marketplace that connects individuals to interventions and treatments for chronic conditions and disease prevention, like diabetes prevention courses or weight management programs.

Like many fast-growing companies, Solera Health had to move fast to build their customer-facing products—often at the expense of internal tools and processes.

A lot of their internal processes were built on their CRM, with a few one-off applications built for admin tasks. And as the company grew, they realized it was time for more custom and scalable internal tooling.

Kenneth Molnar, a Dev Ops Engineer, and Kee Han Ooi, a Software Engineer, decided to scope out replacing Solera's internal tooling with React apps. “But we just didn’t need the same level of control and polish on our internal tools as the tools we were building for our providers—not to mention, we simply didn’t have the time to build React tools for everything,” explains Kenneth.

This is the story of why Solera Health chose to build custom apps in Retool instead of using React, and how those CRUD apps reduced friction and sped up workflows for customer support agents.

The cost of building React apps

Kenneth and Kee Han agreed that the process of building React apps from scratch was too time-consuming, notably because:

• Maintaining and testing all of the packages one by one is a slow process, especially when the team needs to update specific packages and be sure that they won’t break the application.
• Even when using a library like Material UI, creating components from scratch is still slower than using an out-of-the-box solution.
• Different permissions across the organization were a necessary day-one feature. When building a single destination for internal admin tooling, users with different job functions needed different levels of permissions, requiring the team to choose between making an extensive single application with a complex and flexible permission model, or smaller, more straightforward applications.

Not only was building React apps from scratch slow, but it also affected how they allocated team resources. More custom work meant more developers building and maintaining tooling.

At this time, they had a robust set of internal tooling for existing products that helped non-developers do their work. But as new platforms or products launched, the equivalent tooling took time to develop—meaning operational support tasks that were normally done by other teams had to be handled by developers until the tooling could be built.

Even if React apps could solve the problem well, the cost of slowing down new core product development was too high. “We had to find a better way to build internal tools,” says Kee Han. Soon after that, Solera’s CTO started looking into low-code and no-code solutions.

Looking for a better way to build apps

When looking for a new internal tooling platform, the team prioritized:

• Accelerating internal tool building
• Iterating on internal tools faster
• Utilizing fewer dev resources
• Allow engineering to be more focused on customer-centric initiatives

When they found Retool, it checked all the boxes, and provided a simple way to move away from React.

“Retool eliminates the pain of building React apps from scratch and gives us the best of custom tooling,” explains Kenneth. “It’s great because it’s technically a single application (Retool itself), but we can build small, tailored apps by job function on top of it— without the infrastructure overhead of actually managing multiple small applications.”

Moving to Retool: The technical details

Here's how Solera chose to deploy Retool:

• Solera uses an on-premise version of Retool
• They use Retool on a Kubernetes cluster
• They rely on single-sign-on to streamline access

Kenneth and Kee Han first installed Retool on a Kubernetes cluster in a non-production environment.  

Then they configured single-sign-on with their identity provider (to demonstrate the ability to interact with their platform APIs using the same authentication models they use in their scratch-built applications).

Because their platform APIs do most of the heavy lifting around security, this increased their confidence in Retool from a security standpoint.

Finally, they built a few quick POC apps with various resource types to show that Retool could communicate with every kind of data source they anticipated needing in the short term (API, BigQuery, SQL, etc.).

At this point, they were convinced they wanted to move forward with making things more production-ready. To do that, they needed to:

• Enable a good development workflow to move things from development to production
• Set up a separate cluster for the two environments
• Automate upgrades to Retool itself so that someone wasn't having to execute commands on the Kubernetes cluster manually

So they:

• Enabled Git SYNC in their dev environment in a Read/Write fashion
• Converted their original POC YAML files for the Kubernetes cluster config into Helm charts and put those in source control
• Built a release pipeline in Azure DevOps to be able to deploy changes to the Retool infrastructure configuration

They then built out a production Kubernetes cluster and deployed Retool to it (configured to be Read Only on GIT Sync). They set up pull request workflows in Azure DevOps so that application developers could bundle all of the changes into a single pull request and deploy it cleanly to production.

“At that point, we had a nice workflow for developing apps directly in lower environments and then pushing them to prod via a PR when ready,” explains Kee Han. “The process went very smoothly.”

Centralizing information and workflows

Kee Han single-handedly built several Retool apps used across the organization, including a provider admin dashboard, central contracts and data dashboard, an admin portal for Retool analytics, and a customer service dashboard.

Provider Admin Dashboard

Purpose: Allow Solera to turn providers on and off for payers.

Before Retool: Non-technical staff members had no way of accessing or modifying the data.

With Retool: Kee Han created a simple UI interface where a user can enable or disable a provider with the click of two or three buttons.

Primary benefit: Saves developer time because the alternative was to create another React app—which would have taken a ton of time.

Using Retool for our Provider Admin Dashboard is foolproof.
Kee Han Ooi, Software Engineer, Solera Health

Solera CareManager Dashboard

Purpose: Empower customer-facing agents to find information to better assist patients.

Before Retool: Agents had to visit multiple data sources to find relevant patient information and respond to their requests.

With Retool: All patient information, such as programs, their programs ID, milestones, weekly assessment, history, and all their different activities, are in one place.

Primary benefit: Helps agents see critical information about patients, change information, and better serve patients.

Retool admin portal

Purpose: Track Retool usage, app changes, and user behavior to build better internal apps and understand what’s working.

Moving faster with Retool

Using Retool has provided Kenneth, Kee Han, and the entire Solera team an end-to-end app development process that's faster and easier to maintain.

“We’ve been able to rapidly and inexpensively crunch out applications that are very useful to our team,” explains Kenneth.

Feature requests or changes to tools used to take at least a week to be addressed, but with Retool, they can be made the same day.
Kenneth Molnar, DevOps Engineer, Solera Health

What’s more, they've enjoyed building Retool apps. “Retool offers us prebuilt components and integration with resources that we otherwise would have to build,” Kee Han says.

“This speeds up our process and reduces our need to maintain package updates—in React, we’d have to update over 100 packages, but with Retool, we only need to update the Retool version, and the packages are updated automatically,” he adds.

The Solera team has also leveraged Retool’s customer support team, providing constant feedback and testing new applications and modules.

“Ultimately, Retool empowers us to provide a better tooling service level to our internal users than in the past and, as a result, better serve our customers,” Kee Han says.

By eliminating technical headaches from building apps in React and providing custom, easily updated solutions, Solera Health can focus on what they do best: delivering health solutions to their partners and patients.

In this post, we’ll show you how to build a simple yet powerful admin panel for your MongoDB instance. Using MongoDB’s sample data, we’ll demonstrate how to query data, build tables and components, and use inline JavaScript to customize them—basically, everything you need in a great MongoDB client/admin panel/GUI with Retool (interested in other options? Check out our 2021 guide to best MongoDB GUIs).

Let’s dive in.

Reading data from MongoDB

Creating your new app in Retool (you can try Retool for free) will give you a blank canvas to which you can drag and drop UI components, set up queries, browse metadata for your queries, and much much more.

Let's drag a table to the canvas; it will pre-fill with JSON placeholder data.

To connect your MongoDB data, click on “Resources” > “Create a new resource”:

Hot tip: A simple Command +K will open Retool’s omnibox, which will help you find pretty much anything anywhere within your Retool app. Use it to pull up any resource ultra fast.

For more information check out our docs on connecting to MongoDB. Also, check out this walkthrough guide to help get your Atlas setup connected, and build a sample listing approval tool using Mongo's sample_airbnb dataset.

Back to our sample app: we connected to our MongoDB Atlas instance, where we’ve preloaded sample datasets that come with MongoDB. We’ll work with MongoDB’s “sales” sample set: it contains around 5000 sales orders, each including items like prices, quantities, customer information, whether a coupon was used, and when the order happened:

Let’s pull this data into our Retool UI. We’ll change the query to reference our MongoDB resource, rename the query to “listOrders'', use the “find” action on the “sales” collection, then run the query to return our sales order data. Dragging a table onto the UI panel will then automatically populate the table with data from our last saved query results, which will be our sales orders data.

Remember to save queries!

Retool doesn’t auto-save queries, so please remember to always save after editing a query.

Building a user interface to make best use of the data

Since there is a lot of data here, let’s set a limit to 100 orders/results at a time, then change the table to Compact mode which will make it easier to see the data.

Retool lets you inspect data in each cell: in this case, customer data is a JSON object with properties like gender, age and email.  

If we wanted to only display certain information in this column — say customer email — we can use JavaScript to reference the right cell and accomplish this. While we are at it, we can also update the column title on the fly.

Similarly, rather than seeing all items in the “Items” column (which came as an array of JSON objects for each of the items in the order), we can choose to simply display the number of items in the order by using `{{self.length}}`

Taking advantage of Retool’s UI components: JSON explorer, containers, and more

With our MongoDB data in an admin panel, we want to maximize the usefulness of the interface so that we can navigate the order data better. A great way to do that is to separate individual data into different components.

Let’s say we wanted to have a better view into customer information. This is but one of many use cases for Retool’s JSON explorer component. We can put it in a nifty container, give it a name, change the background, and overall make it more user-friendly.

To see additional items in this order, let’s drag over another container with a table which we’ll call “Order items”. We can also put the price data in an easier-to-read format by overwriting the value in the cell with the value nested in the object. We do this by referencing `{{self.$numberDecimal}}`.

To make the table more readable, we can hide the tag column in the table itself—choosing to instead show tags in a multi-select component in the same container.

Retool offers many options for formatting tables, containers, and the overall dashboard. You can add other sophisticated text components, change background and font colors, use Markdown for table headers, etc.

Filtering items in MongoDB

If we wanted to search for a specific customer’s order, we’d want to add some simple filtering ability: type in a customer email and query MongoDB for records associated with this customer. We can do this by modifying our listOrders query by adding a sorting order and a query structure:

We then write some JavaScript using the ternary operator to quickly generate a dynamic query input based on if there is a value populated in the email text input field, `textinput1`. Additionally, we set the listOrders query dropdown to “Run query automatically when inputs change.” Now we have the ability to filter the table, but also scroll through the orders and easily see each individual one with its relevant data in designated components.

There is a lot more you can do

In this tutorial, we went through building a basic MongoDB GUI, with some simple components and actions. Hopefully, you’ve gleaned the customization capabilities with inline JavaScript, and some query manipulation. To see more, including creating, deleting, updating, and sorting items in MongoDB, check out this video:

And for some sophisticated use cases for Retool admin panels, watch our Lightning Demos series, including short demos from Coursera, Segment, and Neo4j.

If you’re a modern web developer, chances are you’ve interacted with PostgreSQL (“Postgres” for short). It’s the second most popular database among developers overall, and almost 70% say they love working with it.

PostgreSQL ships with a built-in CLI called psql, but some don't prefer to write queries via the command line. This post will review the best PostgreSQL GUI tools available for querying, visualizing, and analyzing your Postgres data, as well as remotely accessing and navigating database servers.

1) pgAdmin

Overview

PgAdmin is one of the most popular GUIs available for Postgres users. Database objects are immediately easy to find on a left hand menu. PgAdmin is on it’s fourth major version and supports all of PostgreSQL’s features while also being open-source.

Strong Points

PgAdmin’s greatest strength is that anybody can use it, anywhere. You can configure it to run on any cloud server and then access it from all of the major operating systems; Windows, Linux, and MacOS.

PgAdmin runs as a web application, meaning it can be deployed on any server, including your computer. This is convenient if you’re running Postgres as a distributed database across multiple servers, as you can include PgAdmin on each. Admittedly, this is a feature more targeted at the Database Administrator (DBA) level than the Analyst or Engineer level, which involves more SQL than production database management.

Useful Shortcuts for your Editor

SQL Query Editors are where most Postgres users spend their time when manipulating data. PgAdmin’s SQL Editor provides an extensive list of useful shortcuts for quality of life improvements. They cover most of what you’d want to accomplish when writing queries that need maintenance friendly white space.

Drawbacks

The main drawback of PgAdmin is installation barriers, especially for SQL developers who aren’t experts at the command line. Running a Postgres GUI as a web application from your terminal is something that newcomers should not be expected to figure out from the ground up. Managing multiple servers, databases, and the usage that comes with them, is definitely a more advanced terminal skillset.

2) Navicat

Overview

Navicat is not as popular as PgAdmin but definitely comes with many of the features you would expect from software that makes talking to databases easier. Navicat is a paid tool and isn’t open-source, so it comes with many more features than the typical open-source tool. Unlike pgAdmin, for example, Navicat supports multiple SQL dialects, like MongoDB, MySQL, and PostgreSQL.

Strong Points

Installation of Navicat requires no more than three lines of terminal commands in Ubuntu. It is easy to get up and running and has multiple features which make it a great choice for team collaboration. You can easily improve team productivity for the SQL your team writes via Navicat’s job scheduler.

An add-on feature called Navicat Cloud also allows for Navicat SQL-specific team collaboration. This cloud friendliness extends to how easy it is to connect to data sources, like cloud databases, local flat files, or SSH tunneling and SSL.

Navicat also comes with a powerful data modeling tool, which lets you visualize database structures and design schemas.

Modern Aesthetic

The aesthetic of Navicat’s GUI is slicker and more modern than pgAdmin’s. One of the neat things about Navicat is that it gives the user a choice of dark or light theme from the start (for those dark mode die hards out there).

Drawbacks

The main drawback to Navicat is the price. Cost may not be as much of an issue for a business looking to maximize their database users’ efficiency, but it could be frustrating if you’re an individual looking for a simpler query tool. The Navicat trial is only available for 14 days, and you have to buy licenses to be able to work with PostgreSQL or MySQL.

Navicat for PostgreSQL pricing consists of three tiers: non-commercial ($119), standard ($199), and enterprise ($299).

3) DBeaver

Overview

DBeaver is open source like PgAdmin. However, it supports different types of databases like Navicat. DBeaver also has an enterprise version which provides advanced plugins for productivity. You can run DBeaver on all of the common Operating Systems; Windows, Linux, and MacOS, and import and export data from a variety of file formats, including CSV, HTML, XML, JSON, XLS, and XLSX.

Strong Points

At least for beginners, the best thing about DBeaver (at least in how it compares to the other GUIs so far) is that it runs as a desktop application. Database objects are easy to find on the left-hand side menu, and connecting to my local Postgres database was intuitive. No CLI experience is necessary for you to start.

DBeaver, being open-source, has both free and paid options. An easy-to-sell concept: start with a deadline-less free DBeaver and transition into a paid tier as your organization’s needs scale.

Drawbacks

DBeaver’s main strength is also its main weakness: desktop applications only have as much power as your machine. To unlock the productivity levels you need in distributed development situations, you’ll have to turn to its enterprise option.

4) HeidiSQL

Overview

HeidiSQL is the only GUI on this list that was built exclusively for Windows. Just like DBeaver and Navicat, HeidiSQL can connect to different database drivers, like MySQL, Microsoft SQL Server, and PostgreSQL. HeidiSQL is free and open-source.

Strong Points

Like many Windows desktop applications, HeidiSQL is easy to download and install. If you’re siloed in Windows and your IT department is firm on that, HeidiSQL is a great option for connecting to a Postgres database.

I was able to connect to a database with only a handful of credential fields. The console prints out the commands that the GUI executes in real time — much like a log. This visibility into the back end makes it a useful tool for debugging and troubleshooting database problems.

Drawbacks

HeidiSQL is pretty lightweight, so it’s missing some of the power features that advanced users might need, like a debugger, and has no cross-platform support.

5) Datagrip

Overview

Datagrip is a cross-platform integrated development environment (IDE) from the folks over at JetBrains (makers of IntelliJ, PyCharm, etc.). That means, you can use it on Macs, Windows, and Linux. Unlike PgAdmin or Navicat, it is not a web application and can run as a local application like Spotify, VSCode, or RStudio.

Strong Points

DataGrip is intense, and it’s built from the ground up for power and customizability, ranging from dark themes to plugins for the many database systems and dialects available.

As an Ubuntu (Linux) OS user, installing dependencies requires two bash CLI commands. Installing DataGrip only requires one. A single terminal with an open log remains open when I launch DataGrip. This terminal prints out log information about the app as it's running. You can run it in the background, but I like DataGrip’s balance between command-line usage and desktop application.

Drawbacks

With a range of plugins and up-to-date development, it’s no surprise that DataGrip is a paid tool at $199 per year, per user, for the first year ($159.00 for the second year and $119.00 thereafter). Unlike pgAdmin or Navicat, DataGrip is not built to be an administrator web application that you can deploy on any cloud server. It’s made for querying.

DataGrip is more than enough for many small businesses because a desktop application can help them solve most of their urgent database problems on one or a few computers. That said, another solution may be better for deploying and managing many Postgres DBs.

6) OmniDB

Overview

OmniDB is open-source software that works on Mac, Windows, and Linux. It’s focused on lightweight, no-frills, Postgres database management.

Strong Points

Despite being open-source, OmniDB retains a lot of the SQL development features that a lot of the paid GUIs have, including features like SQL autocomplete, syntax highlighting, customizable charts for database metrics, and complete debugging tooling. Release notes show that OmniDB is most focused on Postgres.

Drawbacks

OmniDB is a lightweight tool, meaning it works great for one or a few SQL developers who need a free option for fundamental database work. It’s not, however, the best option for SQL developers who need a wide community of support, documentation, and at-scale deployment for their databases.

7) Beekeeper Studio

Overview

Beekeeper Studio is a cross-platform open-source database management desktop app that works on Mac, Linux, and Windows. It supports a broad set of databases, including PostgreSQL, MySQL, SQLite, SQL Server, CockroachDB, and Redshift.

Strong Points

Beekeeper Studio is focused on providing a smooth, fast, and easy-to-use interface, as opposed to a powerful, keyboard-shortcut-based nightmare. Typical tasks, like quickly updating a database table or running a SQL query, are super quick and simple.

Another benefit: the Beekeeper Studio team is committed to staying open-source and never adding any user tracking or user monitoring. This commitment to privacy is a unique promise among the apps we’ve reviewed here.

Drawbacks

Beekeeper Studio doesn’t have as many bells and whistles as DBeaver or DataGrip, so if you’re a DBA or need sophisticated performance monitoring and profiling tools, you’re better off with something like DataGrip or DBeaver.

8) TablePlus

Overview

TablePlus is a modern, native GUI tool for relational databases, such as MySQL, PostgreSQL, SQLite, and a few NoSQL databases like MongoDB. The TablePlus team is fairly active on GitHub — the only people behind the company being founder Henry Pham and Windows developer Raccoon Thai.

Strong Points

TablePlus is slick. It provides a customizable user interface (UI), meaning you don’t have to use Mojave at all. You can customize your configurations and their appearance as much as you like.

That slickness, however, doesn’t belie an unsophisticated tool. A standout among many TablePlus features is its database security functionalities. When you use TablePlus, the connection between you and your database is end-to-end encrypted. That encryption means no data is sent to a TablePlus server. Additionally, TablePlus comes with built-in SSH and ensures your database credentials are stored securely in your device’s keychain.

Drawbacks

Despite the slickness of its UI, some TablePlus users have pointed out how difficult it is to carve out a unified UX. An advantage to TablePlus is that it supports a wide range of databases, but a weakness of that approach is that the UX of all of them can suffer. Luckily, if you’re using it as a Postgres GUI, you’ll likely find the support you need. Users noted it suffered more when it came to things like Redis.

9) QueryPie

Overview

QueryPie is a cross-platform database IDE for Mac, Windows, and Linux. QueryPie promises to provide data access governance, from the cloud to on-premises to a variety of other platforms up to and including various SQL tools.

Strong Points

QueryPie stands out for a few different features, including:

• Auto-complete, giving you the ability to write your queries faster.
• Multi-query, multi-results, giving you an intuitive UI that makes query search and execution faster. You can also view multiple query results simultaneously.
• In-line data edit, giving you the ability to edit query results and table structure directly and easily.

QueryPie also has some unique features when it comes to Snowflake, so if you’re interested in expanding beyond Postgres, QueryPie is worth considering.

Drawbacks

The QueryPie team announced its MVP in 2019, and updates have been sparse since. On their blog, a majority of recent posts date back to early 2020. Though the tool appears robust and useful, you may want to look elsewhere if you’re looking for a product that comes with more tutorials and up-to-date content.

10) SQLGate

Overview

SQLGate is an integrated tool for database management and development. It promises to simplify how you construct and operate databases. It works with Oracle, SQL Server, MySQL, MariaDB, Tibero, DB2, and, of course, PostgreSQL. Together, according to SQLGate, these databases make up 83.2% of the database management system (DBMS) market, meaning using SQLGate will allow you to manage most of the DBMS tools out there.

Strong Points

SQLGate has a few features that make it especially useful for database operators and analysts (though SQLGate also says it’s useful and accessible to developers, planners, and marketers, too).

• Direct database connections, meaning you can connect without any complex Postgres client installations.
• Big data processing, giving you the ability to quickly export query results (even massive amounts of them) to Excel.
• Ultralight design, proven by the fact that the entire app and all of its functions are contained in less than 50MB.

Drawbacks

Pricing, like Navicat, is SQLGate’s main drawback. SQLGate is the most expensive tool on this list, coming in at $300 for an indie developer license and about $500 (you have to contact them for specifics, so it could be higher) for an enterprise license. With the amount of open-source and cheaper options on this list, you should take a close look at the unique benefits this Postgres GUI option provides — or else look elsewhere.

11) Retool

Overview

Retool is a web-based tool for building internal tools and applications on top of your data. It connects to all modern databases (Postgres, MySQL, MongoDB, and even Oracle) and any REST API, as well as third-party APIs like Stripe and Twilio.

Strong Points

Retool connects to pretty much anything, which is useful if you’ve got more than one data source to work with. You can access and work with your Postgres DBs and your MongoDB collections in the same GUI, all from your browser. Retool also puts a GUI wrapper over write operations so you can avoid accidentally writing DROP TABLE and getting yelled at.

Retool saves engineering time, too, as proven by our customer stories. Just look at Avo, which saved hundreds of hours of engineering time by implementing Retool.

If you’re building tools on top of your data, Retool saves you time by providing the reusable components you need: tables, buttons, text inputs, and even custom components. Retool is cloud-hosted, so the GUI is accessible from any major operating system and any major browser.

Drawbacks

Retool isn’t specifically focused on Postgres (like OmniDB), and is missing some advanced features like a query debugger.

Retool gives you a complete set powerful building blocks for building internal tools: Assemble your app in 30 seconds by dragging and dropping from 50+ pre-built components. Connect to Postgres and dozens of data integrations and anything with a REST or GraphQL API. Get started for free👉

Choosing between these PostgreSQL GUIs

Which is the best PostgreSQL GUI? The answer is: it depends. If you’re a single analyst looking to move into transparent and reproducible workflows with a single instance of a database, then DBeaver, Beekeeper Studio, DataGrip, or HeidiSQL are your best bets.

If you are part of a larger team, however, then paying for Navicat may be the best option because of Navicat’s team collaboration focus.

pgAdmin is the only PostgreSQL native GUI — plus, it’s totally free and scales easily across multiple servers. pgAdmin makes for a great choice for Postgres-focused DBAs. That said, a need for distributed servers usually only arises for skilled developers who can tackle this kind of configuration.

Retool shines when you’re working with multiple data sources. Modern developers rarely stay in one ecosystem like Postgres. As an organization grows, data workers have a growing list of stakeholders who need and want visibility for their metrics. Integrating multiple data sources with clicks and transforming with SQL is my preferred method of data manipulation because it minimizes developer time and maximizes domain-specific knowledge about your own data.

Earnin empowers people to control their finances with a variety of services and products that give customers flexibility, access to, and control over their money.

Their products play a critical role in a lot of their customers' finances, as they help eliminate the wait for payday, it helps their customers pay bills on time, and save sooner—all with no mandatory fees (1).

In fact, 84% of their customers said that Earnin reduced their financial stress during COVID-19 (2).

But helping customers with finances is often very time-sensitive—like paying bills or rent on time—so it’s mission-critical that Earnin provides support to their customers quickly and reliably.

That’s where Paula Obler, a Software Engineer on the team at Earnin, comes in. She builds tools for Earnin customer service agents and internal teams so that customers get help when they need it—and have access to their earned money.

This is the story how Paula built a new customer service tool in Retool to help the customer support team prepare for the launch of their new feature, WeWin (3).

Scaling—and hitting a breaking point for legacy tools

In the early days at Earnin, the engineering team built custom internal tooling for the customer service team that supported their basic needs.

As they scaled both teams and product offerings, however, it became obvious that they would need more robust and comprehensive tools. As a result of their aging tooling, the customer service team suffered—and so did the support they provided to Earnin customers.

Their homegrown solution initially displayed way too much information and was confusing to navigate.

“The data wasn’t organized in a way that matched agents’ workflows, so they lost time hopping from tool to tool in order to gather the necessary information to serve customers,” Paula explains.

The entire customer support process was slowed down as a result, and our customer experience was impacted.

What’s more, onboarding new agents was a challenge because the internal tool wasn’t intuitive or streamlined. As the company started growing faster, the need to improve the onboarding process started to hit a breaking point.

On top of that, another consequence of the old tooling was something Paula felt in her day-to-day: “Developing new or updating old internal tools was a slow and laborious process,” she explains. “The tools existed in a legacy repo and used an old UI framework, which was clunky for developers and reduced our interest in improving our internal tools.”

With the launch of WeWin, an incentive feature where users could have a chance to earn up to $10M as they saved more money, Paula and her team wanted to build a better tool that would streamline the customer support workflow, thereby allowing agents to access information faster and respond to customers with more confidence to customer requests.

They needed to create a tool that matched—and optimized—agents’ workflows. It was important that they help minimize the cognitive load of responding to support requests so helping customers would be simple, not confusing.

Because requests are often time-sensitive and financially impactful, Paula wanted the new tools to empower agents to really engage with the issues customers brought forth, instead of spending their time managing the workflow around the issue.

Finally, as a developer, Paula hoped to improve her own team’s experience of developing tools for customer support agents and other internal stakeholders alike. By speeding up the release cycle for making changes to their internal tools, agents and developers would be better able to sustain the company’s rapid growth.

Empowering the customer support team with Retool

Paula started by developing a customer service tool to support their WeWin feature.

For every $10 Earnin customers save, they’re entered for a chance to win money weekly. Using Retool, Paula built a service dashboard that empowers agents to respond to customer requests and issues quickly and easily.

In the Retool dashboard, agents can search for a customer’s user ID, see all the WeWin numbers that have been drawn for the customer, see their ticket entries, and more.

“All of the customer data is displayed in one place and agents can take actions right from Retool,” Paula explains. “They no longer have to jump from tab to tab to find information or resolve the customer’s request.”

Paula and her team are also building a workflow that covers the most frequently asked questions from agents, displays key customer details for a bird’s eye view, and provides action buttons to further reduce the time it takes to help a customer.

Simplified, streamlined workflows—for both agents and developers

Using Retool makes managing customer requests easier and it improves several internal workflows, too.

From onboarding new agents—which is quick and simple using the new Retool workflow—to faster and more enjoyable development cycles for development, Retool has streamlined how Paula and her team work with the entire Earnin team.

“Our developers can now involve agents in the development process thanks to the ease of creating mockups, getting feedback, and iterating within Retool,” Paula explains.

For example, the two engineers who manage support tools can create several versions of a new feature—like their new FAQs dashboard—and test them out with agents, gather feedback, and iterate. “It’s far more effective than using wireframes because agents can actually use the tool as we’re developing and iterating,” she adds.

Because Earnin is a mobile-based application, Paula and her team don’t have the tooling to manage web UI development—something that made building internal tools tricky.

“Using Retool eliminates the need for a frontend codebase and reduces the load on our developers,” Paula says. “It’s one less thing for us to think about because Retool automates the frontend away.”

Saving time and launching faster

Paula and her team have already noticed improvements in their workflows and abilities to help agents respond faster and more proficiently to customer requests.

Moving forward, they’ll track new Retool feature success by asking agents for feedback and gathering suggestions for improvements to the internal tools.

They’ll also measure training time for agents and chat handle time, aiming to vastly reduce the time and effort it takes to both onboard new agents and respond to customer inquiries.

“We’ve already seen improvements in our development time since launching the WeWin customer support tool,” says Paula.

Instead of months, we launched a Retool app in two weeks because our developers didn't have to build out a frontend repo with custom UI.

The Earnin team will continue to track time savings for the development team, agents, and customers alike—all in the spirit of driving better financial control for all.

Want more? Check out Paula's demo from our Retool Lightning Demos series.

(1) Restrictions and/or third party fees may apply, see Earnin.com/TOS for details.

(2) Earnin Survey Dec 10 2020 - Jan 1, 2021: 1122 Responses

(3) Disclaimer NO PURCHASE NECESSARY TO ENTER OR WIN. Must be 18 years of age or older and a legal resident of the U.S. or DC. Games begin each Sunday starting 12/6/20 at 9:01 p.m. ET and end the following Monday at 9:00 p.m. ET with the last Game ending 12/19/21. To download the App, view the Official Rules, odds disclosures, prize details, and alternate means of entry, visithttps://www.earnin.com/wewin/ . Void where prohibited. $10,000,000 grand prize payable over 29 years. Sponsor: Activehours, Inc. (d/b/a Earnin ®), 200 Portage Ave, Palo Alto, CA 94306.

While spreadsheet software has evolved over the years—first VisiCalc, then Lotus, Excel and now Google Sheets—the core abstractions have remained the same.They’re flexible, intuitive, and accessible.

But these abstractions make spreadsheets bad at certain tasks.In particular, entering data is error-prone (no validation), and building interactive interfaces is difficult. You could get a spreadsheet to do almost anything, but you probably shouldn't.

Retool is a fast way of building UIs and internal tools. And because Google Sheets is probably the lowest-friction way to store and use structured data online, Google Sheets is where many internal tools start. This post will show you how to use Retool to make powerful apps from Google Sheets. You’ll be able to build internal tools on top of any Google Sheet in just a few minutes.

For example, if you work in sales, you can pull in your Google Sheet with leads, and send each one a personalized email by simply pressing a button. If you’re an ecommerce company, you can have operators submit orders via Google Sheets, and then build a UI to run an API request for each row.

Because Google Sheets is the lowest-friction way to store and use structured data online, we built a native integration to dramatically reduce the amount of work it takes to build a tool on top a Google Sheet.

Tutorial: building a tool to contact sales leads

Let's say you're a venture capital firm. During an accelerator's "demo day", you recorded a list of companies that look promising. Using a full-blown CRM to compile this list would be overkill, so you used Google Sheets:

Now, you want to go through the spreadsheet company by company, and send each contact a follow-up email. Before, you’d have to write every email “by hand”. But now, with Retool, you can create an app on top of your Google Sheets data, and fire off a templatized email to each company by simply pressing a button.

Here’s the final app. Feel free to click around on different rows, enter in an email address, send some emails, etc.

Lightning demos: how Coursera, Segment and Brex went from spreadsheets to applications

For more sophisticated use cases where companies replaced multitudes of Google Sheets used internally with some powerful apps, check out our lightning demos:

A few simple use cases

Simple inventory tracker

If you run an ecommerce business, you probably have operations teams heavily dependent on Google Sheets for use cases like inventory tracking, supply chain, and delivery tracking.

You might face an issue of too many people editing the sheet, or example - editing item quantity or adding new products. If you are looking for a more controlled experience, you can build the UI on Retool so you don’t risk your team accidentally deleting rows or manipulating the wrong cell.

Custom CRM

You might have heard the saying “all CRMs start as spreadsheets”. Your spreadsheets could be missing some custom field requirements and views but you make do—you also don’t want to move to a completely new setup and spend time implementing it.

A custom UI on top of a sheet can help you achieve that complexity while keeping your underlying database intact:

Customizable email automation

Let's say you wanted to email a bunch of people (sales contacts, hackathon attendees, survey respondents...). You want to use a template, yet personalize each message a little bit. Unfortunately, standard email marketing automation systems are not customizable enough for this use case. Retool to the rescue!

Check out this video on converting a Google Sheet app to a customizable email "automator":

Applicant tracking system

Almost every company today uses a candidate applicant tracking system, and smaller shops might use a Google sheet that is potentially hooked up to a Google Form/Typeform.

You might want to build an interface to help easily switch candidate stages, add custom notes, send emails, and enable custom views. With a simple Retool app you can keep your sheet structure as your back end, and create a UI front end that’s easy to use for anyone in your company.

Combining your Google sheets with external data sources

Retool lets you pull in and combine data from different sources, including your databases and APIs. If you have some data in Google Sheets, you can enrich it by joining it to data from another source.

For example, you could enrich your list of leads above with data from your own Gmail, such that it shows when you last contacted each person.You could also connect Retool to Clearbit’s API to enrich leads directly in the sheet you use.

In a different scenario, you can export data into Google Sheets for analysis. Spreadsheets are the tool of choice for many analysts (business/finance/data) to quickly manipulate data. If you have internal data in databases/APIs, you can quickly build a Retool app to export it to Google Sheets. This is useful when you want to quickly create financial models in Sheets based on data you have in your database / API.

For example, you could model different growth scenarios for your company, based on the data you have in Stripe. You can create a tool to generate new Sheets (with your template for financial modeling). And because your templates have pre-existing formulas + structure, the new data will flow into them, and all your forecasts will be refreshed with your new numbers.

Connecting to Google Sheets is available to all Retool users. Let us know if you've got any feedback — we love talking to users!

Customer journeys can be incredibly complex. A customer might see any number of your ads, emails, links, products, and more over the course of their lifecycle. And as people do more things on the internet, companies need a way to make sense of all of this digital data.

Gathering and creating insights from this customer data is no small task. That’s where Segment comes in. Segment helps businesses understand who their customers are and use that information across every team and channel.

Their second product line, Personas, helps developers and marketers build audiences or cohorts of their users based on the information they capture from their website, apps, or SaaS platforms. With real-time audiences, businesses can engage with their customers on a whole new level.

But audiences for global enterprises with huge reach can be incredibly complex. Alex Millet, a product manager on the Personas product, realized that supporting this scale of customers required giving internal teams a new level of visibility. Here’s how he made it happen.

A need to better equip support teams

What Alex found was that offering customers the power to build complex audiences through Personas created a need for Segment's support teams to be better equipped to respond to nuanced issues and incredibly detailed questions.

So Alex and his team decided to give the support team the power to understand the audiences at every level—but they encountered a couple of barriers to doing so:

• Data was difficult to access and consolidate: Customer support couldn’t access and consolidate data to debug customer issues because they hadn't yet built a single source of truth.
  
  As Alex and his team allowed Segment customers to build more complex audiences within the Personas product, the logic got harder and harder to untangle for the support team. When customers ran into issues, the support team had to dig through layers of data from different sources, eating up precious time and resources.
• They lacked clarity on customer support needs: Alex needed to figure out the best way to empower the Personas support team, but he didn’t know what information they were missing. He was looking for more than just a tool to serve up information, he wanted one that would help him understand which information would be most valuable to his team.

Using a data-driven dashboard to support customers

Alex turned to Retool to develop internal tools that would allow the Personas support team to better utilize detailed data from different customers’ audiences, like how they get added to or removed from a customer segment based on their actions.

For example, within Personas, customers can define the conditions of users they want to target with campaigns (to improve odds of conversion or action).

Customers often flag bugs, but the support team didn’t always have the tools to help them—until they started using their Retool dashboard.

When responding to a ticket, customer support agents are usually looking for a specific audience and user—and their Personas Support Dashboard helps them find exactly that.

This Retool dashboard pulls together different data sources into one timeline so that support agents can see all the information about a user or audience in one place.

Using this dashboard, a customer support agent can look at different events—when a user viewed a product, opened an email, or which ad campaign they came from—and when the user was entered into a specific audience.

“When you have 10-20 different conditions, gathering the data and understanding where the issue is coming from can be really complicated,” explains Alex.

Using the Retool dashboard helps our support team pin down where issues are coming from faster and more accurately by stitching all of our data together into a single timeline.

Supporting customers, faster

Using their Retool dashboard, Alex and his team can respond faster to customer requests with more straightforward access to data. They’re no longer digging around, looking for the source of truth, or wondering if an issue is settled.

What’s more, “Using the dashboard’s analytics helps me know which information is most helpful for our support teams, too,” explains Alex.

“With an understanding of how they’re using our Retool dashboard, we can build better tooling for our teams and stay ahead of customer issues instead of trying to fix them after they come up.”

Empowered with better access to nuanced data, the customer support team at Segment is better able to help customers building complex audiences and making the most of their Personas product—a critical success for everyone involved.

To hear more from Angelina, as well as other SaaS experts from Botkeeper, Neo4j, LeadGenius, and Remitly, check out our SaaS Lightning Demo.

Everyone has their favorite local haunts: the bookstore with limited edition hardcovers or the coffee shop with your favorite latte. But behind the scenes at all small businesses is a small team deciding how to accept payments, reward customer loyalty, and more.

To make it happen, many small and medium-sized businesses turn to SaltPay, a payments company with products that help automate point of sale, loyalty wallets, and ways for merchants to accept payments over the phone.

“Our goal is to empower merchants so they can do more and grow their businesses with less effort,” says Miguel Eusébio, who works in Customer Relations at SaltPay. “To do that, we need to first empower our team of agents who support our customers.”

Miguel partners with the tech team to build the internal systems that support agents use to serve merchants and partners. “Together, our goal is to make the SaltPay customer experience as seamless as our products make running a small or medium business,” Miguel explains.

This is the story of how SaltPay was able to bring together critical user data and support workflows into one Retool app to replace a disjointed and slow customer support process.

Focusing on what matters: The core product

As SaltPay acquired more customers over the years, they started to realize that a lot of their existing processes—and the tooling built to support them—needed a major upgrade.

“Agents and our entire customer-facing team were not equipped to best serve merchants, so we weren’t providing the best possible service,” Miguel says.

What’s more, the tech team wasn’t focusing their energy where it was most useful—on building SaltPay’s merchant-facing products.

Instead, product and engineering juggled over 10 back-office systems that were slow and hard to use. “Simply, it was impossible to provide good customer service because of how long it took to perform basic tasks or find simple merchant information,” Miguel explains.

The tech team faced a decision: where should they focus their time?

They could develop back-office apps for support agents or build core products and integrations for merchants to grow their business. They ultimately decided that they needed to focus on building SaltPay and empowering merchants instead of spending all their time on back-office work.

So they sought out a way to make back-office development faster, more efficient, and better able to serve the support team’s needs—without costing them their core product offering.

From 10 back-office solutions to 1: Choosing Retool

“We needed our tech teams to work on expanding and improving our core products as we prepare to scale, so we started looking for a back-office solution,” Miguel says.

More specifically, they were looking for a solution that met the following requirements:

• Would make it easy to build back-office apps without costing the tech team time and development resources
• Provided critical features like SSO and on-premise hosting to ensure security and scalability
• Was built on an API-first infrastructure so integrations would be effortless
  

After investigating a variety of alternatives to their homegrown systems, Miguel discovered Retool. Within just a few days of testing Retool, the team decided to roll it out to power SaltPays back-office needs.

Streamlining Customer Relations with a dashboard

Today, all customer relations agent workflows are powered by a Retool dashboard. “Our goal was to save agents time when handling merchant inquiries or updates, so we built a Retool dashboard where agents can view merchant information in one place,” Miguel explains.

It all starts with an incredibly simple view where agents can search and find merchants.

From there, agents are able to run through any of their most critical processes. The dashboard allows them to:

• Search and find merchants quickly and easily, instead of searching through various databases
• See merchant profiles and important data in one place, rather than toggling between tools to find different metrics and reports
• Take action directly from the dashboard, such as adding or closing an outlet and editing merchant information

Before using Retool, agents had to search through multiple back-office tools, taking time and slowing their responsiveness to customers. “But with our plans to scale and the increasing volume of customers, this method wouldn’t work,” says Miguel.

Now, with a central source of truth, merchant data updates happen in real time and agents only need to navigate to Retool to help a customer—no more tracking information down across multiple tools. Agents are better equipped to respond to requests and customers see their issues resolved faster.

“Retool has allowed us to easily build apps and a user interface for our agents so our tech team can focus on building our product and APIs, in order to empower our customers,” Miguel says.

Empowering agents to provide a better service

Since rolling out the Retool customer relations dashboard, SaltPay agents have access to more tools and are empowered to better help merchants.

What’s more, they’re less dependent on the tech team to respond to requests and build back-office solutions—and when they do need an update to the tool, the tech team can make it happen on the same day.

Finally, all agent workflows are simplified. With fewer manual tasks to complete, agents can move through their days faster and assist more customers.

“Retool saves our team time and helps us provide a better service for customers by empowering agents to respond faster and with more information and allowing our tech team to focus on building, improving, and scaling our core product offering,” Miguel says.

Just as they’re expanding their product offerings for merchants weekly, SaltPay hopes to automate even more back-office tasks using Retool and expand to include other workflows and features, too.

Want more? Check out Miguel's demo from our Retool Lightning Demos series.

Drafting, reviewing, tracking, signing, and storing business documents is essential—and can be painful, especially if you are still in the pen and paper era. Revv, a complete document management system, specializes in migrating from paper documents, converting word docs, excel sheets, and PDFs to digital documents.

Revv also enables you to digitize and automate your document creation and management process. The information represented in a document is collected and put together from multiple Systems of Records (SoRs) like CRM, CPQ, CLM, ERP, etc.

Using Revv and Retool, you can stitch together different Systems of Record and create internal workflows, integrate Revv with your CRM such as Salesforce, and enable the easy flow of information between SoRs.

How to automate document workflow process by integrating Revv and Retool

Revv offers more than 1000 legally vetted ready-to-use NDA and other business document templates that you can use to draft your documents.

To create an NDA, you need to input information of the client with whom you are sharing the document. This information is usually stored in a CRM like Salesforce. Doing this manually is not effective. It slows down the sales process, may lead to loss of data in transit, incorrect information being added to the document, etc.

This is where Retool comes in: with Retool, you can build a UI layer that connects directly to Salesforce and Revv, so you can manage your CRM and Revv updates in one centralized place. You can use Retool to create a simple app that pulls relevant fields from your CRM and use Revv’s APIs to create a custom NDA in a few clicks.

Tutorial: create a Retool NDA workflow app with Revv

If you already have Revv and Retool accounts, you can connect them in minutes using Retool’s REST API integration as shown below.

By integrating with the Revv API, you can access any of Revv’s many API-based actions within Retool to create simple CRUD applications. Some examples of Revv APIs that might be useful:

1. GET/ List All Documents
2. GET/ Document By ID
3. POST/ Create Document
4. POST/ Send Document to Fill & Esign

You can also pull data from Revv to create dashboards and take bulk actions from right inside a Retool app.

To build an app on top of Revv:

1. Connect your REST API in Retool
2. Write relevant queries to pull data from Revv
3. Create a custom UI with Retool’s drag-and-drop components

You can then build your custom UI to work with Revv according to your business’s back-office document needs. In Revv’s sample app, we connect Revv-Retool-Salesforce to pull our users’ information and Revv document actions inside one central dashboard, so we can create and send Revv NDA documents to users in Salesforce.  

Retool comes with a native integration with Salesforce that lets you use Salesforce Object Query Language (SOQL) to query our Salesforce data.

Each row in the table represents a customer to whom the NDA needs to be sent. This information is required to create NDAs (and other business documents) within Revv using Revv’s templates. Just select the rows for which the NDA needs to be generated, then select the folder name (created in Revv) where the NDA needs to be drafted and stored. Choose ‘Create document action’ from the list and click ‘Proceed’.

Note: every time a new Opportunity is created in Salesforce, the information automatically updates in the table due to the smooth Salesforce-Retool-Revv integration.

The created document(s) will be visible in the selected folder within Revv.

You can click and open the documents, edit them further if needed, and send them to other teams for approval—or to the customer for final review and eSignature.

The above integration workflow can be applied to different document use cases. You can, for example:

• Get documents approved in no time. The action for ‘Send for Acceptance’ can be triggered for the same list of documents using Retool and Revv. All you need to do is select the required action to be initiated and the tool does the remaining steps for you.

• Sign documents within minutes. Select the documents that need to go out for signature, select ‘Send for eSign’, and click ‘Proceed”. The trigger will initiate the action and send out a document to respective parties for eSigning.

And voila! You have completed the overall document process.

Check out the demo for the above use cases and let us know if you have any questions: @Revv_so, @retool

Let's build a tool to manage Stripe subscriptions using Retool. The app will allow you to search through all your subscriptions, see all the associated current and upcoming invoices, charges, and products for your customer all in one, clean view. Then you can begin to take actions like exporting invoices or canceling subscriptions:

While Retool does come with a Stripe API integration, configuring a Retool app to search and retrieve data through the Stripe API is tedious. You'll still need to handle pagination, caching, and running multiple, sequential API calls.

Luckily, Sync Inc replicates all your Stripe data to a Postgres database so you can use Retool's first class support for SQL to work with your Stripe data. In this tutorial you'll learn how this all works together to make building your Stripe subscription tools easy.

Stripe Setup

You'll need a Stripe account that contains active subscriptions to build this Retool app. If you don't have any active subscriptions in your LIVE Stripe account, you can easily add some fake ones in your TEST account (in fact - building a staging version of this app using your Stripe account in TEST mode is highly recommended since you're working with sensitive data).

Create test subscriptions

To get going, add a couple test subscriptions to your Stripe account:

Step 1: Login to your Stripe dashboard and put your account into TEST MODE by flipping the View test data switch.

Step 2: Create a recurring product by going to the product page, clicking + Add Product, and filling out the form to create a new product. Double check that the product is configured to be Recurring:

Step 3: Finally, create a new customer with a subscription to the product you just created. To do so, click the Actions button on the customer page and select Create Subscription:

Repeat the process by creating a couple more customers with recurring subscriptions.

Generate a restricted Stripe API key

Sync Inc requires an API key to sync all your Stripe data in real-time. As a best practice, we recommend providing Sync Inc with a restricted API key. To generate a restricted API key:

Step 1: Navigate to the Stripe API keys page by selecting Developers in the left navigation and clicking API keys. Then click the + Create restricted key button.

Step 2: Give your key a name (something like "sync inc" will do just fine). Then provide this new key with the following permissions:

• READ access to everything
• READ & WRITE access to Webhooks
• No access to the CLI

You can get more details by reading Sync Inc's reference for Stripe.

Step 3: Finally, click the Create Key button and keep this new restricted API key handy as you move on to set up Sync Inc.

Sync Inc Setup

With your Stripe API key created, you can now setup Sync Inc to replicate Stripe to a Postgres database:

Step 1: Create or Login to your Sync Inc account.

Step 2: Connect your Stripe account to Sync Inc by going through the tutorial or clicking the Add database button and selecting Stripe.

Step 3: You'll be prompted to enter your Stripe API key. Then, in the destination section, select to have a New Sync Inc database generated. Finally, click Create.

Step 4: Sync Inc will immediately provision you a Postgres database and begin syncing all your Stripe data to it (if you're using a TEST API key, then Sync Inc will only sync your TEST data for free, forever). You'll be provided with credentials for you new database:

Retool Resource Setup

Now, add your Sync Inc database to Retool like any other Postgres database:

Step 1: In a new tab, log into your Retool dashboard. In the top menu bar click Resources and then the blue Create New button.

Step 2: Select Postgres from the list of resource types.

Step 3: Enter the name for your resource (i.e. "Stripe") and then enter the Host, Port, Database name, Database username, and Password for your Sync Inc database. You can copy and paste these from Sync Inc. Then click the blue Create resource button.

Step 4: Retool will confirm that your resource was created. Click Back ro resources for now.

Retool App Setup

With Stripe successfully connected to Retool using Sync Inc, we are ready to build an app that shows all your subscriptions, invoices, and charges in one clean view.

First, get the app set up in Retool.

Step 1: On the Retool app page, click the blue Create new button and select Create a blank app:

Step 2: Give your app a name. Something like Super Subscription Center will work just fine and then click Create app:

Step 3: You'll now see a blank Retool app in edit mode. To start building the app, drag and drop a text field into the header. Then, in the inspector drawer on the right, enter # Super Subscription Center as the value to give your app a name:

This is the basic flow for adding new components to your app:

1. Drag and drop the visual components into your app.
2. Configure the data and interactions for the component.
3. Adjust layout and polish the UI of the component.

You'll follow this construction pattern as you build the rest of the app from here on out.

Searchable subscriptions

With all the foundations in place, you are ready to start building the core functionality of your app - starting with a searchable table that shows all the current subscriptions.

Scaffold the UI

Drag and drop the components that will make up this section of the app onto the canvas:

First, drag a Container component onto the canvas. Resize it to cover about half the width of the app.

Then drag and drop a text input field and place it at the top of the container. This will be your search bar. In the inspector on the right, edit the component's Label to be Email and then to make it look nice select search as the Left icon:

Drag and drop a table component under your newly created search bar and position it to fill up the container. At the end, your app will look something like this:

Query for subscriptions

To add the underlying Stripe data to your app, you'll simply query your Sync Inc database using SQL. To step into this paradigm, let's add a simple set of data with search. Then, we'll refine the query to pull in the exact data you need.

Step 1: Open up the bottom panel and create new query by clicking + New and selecting Resource query:

Step 2: Select the Stripe Postgres database you created earlier as the resource, then enter the SQL statement below:

select
	customer.id as "cus_id",
	customer.name,
	customer.email,
	subscription.id as "sub_id",
	subscription.status,
	subscription.current_period_end,
	subscription.collection_method
from customer
left join subscription
	on customer.id = subscription.customer_id;

When you click the Preview button you'll see that this query pulls in key details about your customers as well as the customer's associated subscriptions via a JOIN with the subscription table.

Step 3: This query looks good for now, so click the Save & Run button and then name the query get_subscriptions by clicking on the query in the list on the left.

Step 4: To pull the data from get_subscriptions into the table in your app, open the right inspector, select your table in the canvas, and then in the data field enter {{get_subscriptions.data}}. The double brackets (i.e. {{}}) indicate that you are using JavaScript in Retool. Then, the get_subscriptions.data is retrieving the data from your query.

You'll immediately see the data from your query populate your table:

Step 5: You're now querying data from Stripe (using SQL!) and populating that data to your table in the UI of your app. Now, add search. To do so, add the following WHERE clause to your get_subscriptions query:

select
	customer.id as "cus_id",
	customer.name,
	customer.email,
	subscription.id as "sub_id",
	subscription.status,
	subscription.current_period_end,
	subscription.collection_method
from customer
left join subscription
	on customer.id = subscription.customer_id
where subscription.status is not null and ({{ !textinput1.value }} or customer.email::text ilike {{ "%" + textinput1.value + "%" }});

This WHERE clause does two things:

• First, it checks if there is a value in the text input box. If there is nothing in the text input, then nothing happens.
• If there is text in the text input, then it uses Postgres ilike to search by the customer's email.

When you click Save & Run you'll now see that when you enter text into the text input you search your table:

Step 6: In addition to customer and subscription data, you also want to see some invoicing data. Specifically, you need see the value of the subscription and what products are included. To do so, update your get_subscriptions query to add the following fields:

select
	customer.id as "cus_id",
	customer.name,
	customer.email,
	subscription.id as "sub_id",
	subscription.status,
	subscription.current_period_end,
	subscription.collection_method,
  invoice.amount_due::numeric,
  line_item.description
from customer
left join subscription
	on customer.id = subscription.customer_id
left join invoice
	on subscription.latest_invoice_id = invoice.id
left join invoice_line_item_map
	on invoice.id = invoice_line_item_map.invoice_id
left join line_item
	on invoice_line_item_map.line_item_id = line_item.id
where subscription.status is not null and ({{ !textinput1.value }} or customer.email::text ilike {{ "%" + textinput1.value + "%" }})

This will pull in the invoice.amount_due and line_item.description details you need by joining to the invoice and line_item table.

You've now queried for all your data and set up search using SQL.

Clean up the table

As a last step, adjust the UI so it shows the data effectively.

Step 1: Select the table and open up the right inspector.

Step 2: Simplify the table by removing data that is only helpful to the app - but not your user. In this case, you can drop the cud_id and sub_id columns as well as the subscription end column by clicking the eye icon.

Step 3: Rename and format each of the columns in your table by select each column in the inspector, formatting the name of the column, and aligning the data type. For instance, for the amount column you can give the column a friendly name like Amount and then for the data type select USD (cents):

You now have a searchable table that returns data to help you evaluate subscriptions. Now, you'll bring in the details.

Subscription details

After you select a subscription in the table you just created, you'll want to see the details of the subscription on the right side of your app. Let's start with the customer and subscription details card in the top right:

For this component, you'll repeat the same construction pattern by first scaffolding the UI, connecting the data, and then cleaning up the interface.

Scaffold the UI

This component is simply a container of text fields that present data about the customer and their subscription in more detail. To lay out the UI, drag and drop a container in the top right portion of the app and add the following placeholder text fields:

To format the text appropriately, use Markdown. For instance, for Customer Name and Status you can format the text as H3 by entering the value as ### Customer Name.

Query for customer and subscription data

Now, replace the placeholder text with real data from Stripe.

You can populate the first several fields in the subscription card with data already available in the table to the left. All you need to do is pull those values into the text components.

Starting with the Customer Name text component, select the component and in the inspector on the right enter the value as ### {{table1.selectedRow.data.name}}:

This tiny JavaScript statement pulls the name value from whatever row is selected in table1. For your end user, this means the text box will immediately show the name of any customer they select in the table.

You can repeat this same data access pattern for the next several fields:

Status

### {{table1.selectedRow.data.status === "active" ? "Active" : table1.selectedRow.data.status === "canceled" ? "Canceled" : "Issue"}}

For status, you'll again pull the value from the selected row in table and utilize a ternary operator to show a user-friendly value for the status of the subscription.

Customer Email | Customer ID

{{table1.selectedRow.data.email}} | {{table1.selectedRow.data.cus_id}}

Here is a nice example of how you can easily concatenate string values in a text component.

Subscription Plan

{{table1.selectedRow.data.description}}

For the subscription plan you can simply return the description for the selected row in table1 as normal.

You've now populated as much of the data in the subscription card as you can from the existing data in Table1. For the rest of the data in this card, you'll need to write new queries.

Turn your attention to the Since:, Spent:, MRR:, and Δ: fields:

For these fields, you want to pull in specific details about the customer so you can easily see how valuable the customer is. To get this data, you'll need to write a new query (get_customer) as well as a helper function (calc_customer_stats).

Starting with the get_customer query, open the bottom drawer and click to create a new query against your Sync Inc database. Then enter the following SQL statement:

SELECT
  customer.id,
  customer.created as "cus_created",
  invoice.number,
  invoice.amount_paid::int as "amount_paid",
  invoice.period_start,
  invoice.period_end,
  invoice.created as "inv_created"
FROM customer
left join invoice
	on customer.id = invoice.customer_id
where customer.id = {{table1.selectedRow.data.cus_id}}
order by invoice.number asc;

This query pulls in some more information about the customer and then performs a JOIN with the invoice table to pull in all their billing history. The WHERE clause at the end filters the data for just the one customer selected in Table1. Last, the ORDER BY clause allows us to sort the results to make working with the data easier in the helper functions.

Click the Save & Run button and then name the query get_customer:

You now have the raw data required to calculate the rest of the fields. While you could use some additional SQL to calculate the specific values for each field, you'll use a JavaScript helper function here.

To build your helper function, click to create a new query and select JavaScript Query:

For this helper function, you want to iterate through the array of data returned from your get_customer query to calculate some metrics:

let index = get_customer.data.amount_paid.length;

let toDollars = (num) => {
  return (num / 100).toLocaleString("en-US", {
    style: "currency",
    currency: "USD",
  });
};

return {
  mrr: toDollars(get_customer.data.amount_paid[index - 1]),
  spend: toDollars(get_customer.data.amount_paid.reduce((i, o) => i + o)),
  growth: toDollars(
    get_customer.data.amount_paid[index - 1] - get_customer.data.amount_paid[0]
  ),
};

This helper function does two things. First, it formats numbers into currency strings using the toDollars() function.

Next, it calculates the metrics you need as follows:

• MRR: is calculated as the amount paid on the most recent invoice (assuming all your customer only have subscription products)
• Spend: is a summation of all the revenue from the customer.
• Growth (i.e. Δ): is simply the difference in value of the most resent invoice compared to the first invoice.

Click Save and then name the query calc_customer_stats.

You want this helper function to run anytime the get_customer query is run. So as a last step, open the get_customer query and have the calc_customer_stats query trigger on success:

With your metrics calculated you can now add these values to the subscription card:

Since

{{moment(get_customer.data.cus_created[0]).format("MMMM DD, YYYY")}}

Here you use moment.js to format the datetime value returned from your get_customer query.

MRR

{{calc_customer_stats.data.mrr}}

Spent

{{calc_customer_stats.data.spend}}

Growth (a.k.a Δ)

{{calc_customer_stats.data.growth}}

There is just one more field to add to your subscription card: details around when the customer will receive their next invoice.

This last field requires one additional query that pulls in the upcoming_invoice details for the customer. Luckily, this data lives in your Sync Inc database.

Click to create another SQL query against your Sync Inc database and enter the following SQL statement:

SELECT
    upcoming_subscription_invoice.next_payment_attempt as "next_invoice_date",
    (upcoming_subscription_invoice.amount_due/100.00)::money as "next_invoice_amount"
from upcoming_subscription_invoice
where upcoming_subscription_invoice.subscription_id = {{table1.selectedRow.data.sub_id}};

Sync Inc maintains tables that show the temporary state of upcoming objects you would otherwise need to use the Stripe API for. In this case, you're pulling in the time period and amount of the next invoice associated to the subscription.

Click the Save & Run button and name this query get_next_invoice:

Now, pull this data into your app's interface by updating the last remaining value in your subscription card with the data retrieved in get_next_invoice:

Next Invoice on **{{moment(get_next_invoice.data.next_invoice_date[0]).format("MMMM Do YYYY")}}** for **{{get_next_invoice.data.next_invoice_amount[0]}}**

To make this value stand out, format the text to be green by using the style options in the inspector:

The subscription card is now complete. When a user selects a subscription in the table, the details of the customer including key metrics and upcoming invoice details are immediately shown. All with SQL.

Invoices, charges, and products

Now, you'll round out the app by showing the customer's prior invoices, charges, and products.

You'll be able to pull in all this data in one additional SQL query and then display it in your app using Retool's List View component.

Keeping with the process, first you'll scaffold the UI components.

Scaffold the UI

The List View component allows you to show a list of items. It can dynamically show more or fewer items depending on how the underlying data changes.

Drag and drop the List View component onto your app and then add a Container component to the top of the list. As soon as you drop the Container into the List View component you'll see it's duplicated three times. This quickly gives you a sense of how the List View component works by showing a new UI component for each item in an array of data.

You'll make the List View component dynamic later, but for now you're just scaffolding the front-end. So to make things easier select the List View component and in the inspector adjust the Number of rows to one for the time being.

Now, add a couple more UI components to the Container you created:

The only flourish here (in addition to the emojis 👏) is the styling on the container with the payment information. You can do the same by selecting the container and editing the style as you did previously with the green text.

Query for invoices, payments, and products

Open the bottom drawer and create a new query for your Sync Inc database. Enter the following SQL statement:

SELECT
  invoice.id as "inv_id",
  invoice.subscription_id as "sub_id",
  invoice.number,
  invoice.created,
  invoice.status,
  (invoice.amount_paid /100.00)::money as "amount",
  invoice.hosted_invoice_url,
  line_item.description as "line_item_description",
  (price.unit_amount/100.00)::money as "unit amount",
  price.recurring_interval,
  product.name as "product",
  charge.id as "charge_id",
  charge.description as "charge_description",
  (charge.amount/100.00)::money as "charge_amount",
  charge.status as "charge_status",
  charge.created as "charge_created"
from invoice
left join charge
	on invoice.charge_id = charge.id
left join invoice_line_item_map
	on invoice.id = invoice_line_item_map.invoice_id
left join line_item
	on invoice_line_item_map.line_item_id = line_item.id
left join price
	on line_item.price_id = price.id
left join product
	on price.product_id = product.id
where invoice.subscription_id = {{table1.selectedRow.data.sub_id}}
group by invoice.id, charge.id, line_item.description, price.unit_amount, product.name, price.recurring_interval
order by invoice.number desc;

This SQL query performs a SELECT across several tables that you JOIN together in order to pull in invoices, line_items, prices, products, and charges. Then, you use the WHERE statement to filter the data down to just the one subscription you have selected in Table1.

Click to Save & Run the query and name it get_current_invoices:

Clean up the list

You'll now link the data from your get_current_invoices query to your UI components.

Select the Invoice # placeholder and replace the value with:

### 🧾 Invoice #: {{get_current_invoices.data.number[i]}}

This statement should look familiar to you with the exception of the [i] at the end. So let's step through this:

• The ### is markdown notation for an H3 text format.
• The double brackets then tell Retool we'll be using JavaScript. The get_current_invoices.data.number pulls in the invoice number from the get_current_invoices query. Because we pull in all the invoices in the get_current_invoices query, this value is actually an array.
• So finally, the [i] is extracting just one value from that array. The variable i is used by the List View component so that you request the same index from the array for every item in the same container in the list. So for instance, the first container in the list will use index 0 and then the second will use index 1. So on and so forth.

After you enter the value, you should see your text component update correctly:

To finish the job, you now need to match the value from the get_current_invoices query to the remaining values in the UI:

You'll now have a clean representation of your customer's invoices:

Finally, you want the number of list items displayed in your list to change depending on the number of invoices associated to a subscription. To do so, select the List View component and change the Number of rows in the inspector to {{get_current_invoices.data.inv_id.length}}:

Add interactions

Your Super Subscription Center is now pulling in all the data you need to find a customer's subscription and evaluate it. Now, add two interactions to your app to start exploring how to mutate your Stripe data using Sync Inc and Retool.

View invoice

To get a hang of interactions, let's start with a simple button that allows a user to see an invoice.

First, drag and drop a button into the container of one of your invoice items.

Then, in the inspector change the text of the button to read View Invoice.

Finally, to make the button trigger an event click the + New link in the Event Handlers section of the inspector. Configure the event as follows:

• Event: Click
• Action: Go to URL
• URL: {{get_current_invoices.data.hosted_invoice_url[i]}}

Since you are already pulling in the URL for the invoice in the get_current_invoices query, you just need to associate this URL to the button.

With the event configured, click the View Invoice button you just created and you'll see the invoice load in a new tab.

Cancel subscription

So far, you've read all your Stripe data using Sync Inc. Sync Inc is a read-only database, so to mutate your Stripe data, you'll use the Stripe API.

For instance, to cancel a subscription, you'll simply make a DELETE request against the Stripe API.

Any mutation you make will then propagate to your Sync Inc database in about 1 second.

Let's step through it. To get started, add a new Stripe API resource to Retool:

Step 1: Open up the bottom drawer and create a new resource query. In the Resource dropdown, select Create new resource:

Step 2: You'll be taken to Retool's resource page. Select to create a new Stripe resource.

Step 3: Give the new resource a name (something like Stripe API) and enter your API key. Here, you'll want to generate a new restricted API key for Retool that includes WRITE permissions as well.

Step 4: Click Create resource and then navigate back to your app.

Back in your Super Subscription Center app, open the bottom drawer, and click to create a new resource.

Select the Stripe API resource you just created and then select the DELETE /v1/subscriptions/{subscription_exposed_id} as the operation.

You want to delete the subscription that the user has selected, so in the PATH section, set the subscription_exposed_id to {{table1.selectedRow.data.sub_id}}.

After the user deletes a subscription, you also want to update the subscription's status in the app to close the feedback loop and let the user know the subscription has indeed been canceled. To do so, set the get_subscriptions query to trigger when your Stripe API call succeeds.

All together, your Stripe API query to delete subscriptions will look like this:

Deleting a subscription is a big action. So click the Advanced tab and make the following changes:

• Select to Show a confirmation modal before running. This will ensure the user needs to confirm the action so they wield this power with caution.
• Then, set the Run triggered queries after to 1000 - this will ensure that your Sync Inc database is fully up-to-date before you refresh the data on the page to confirm the subscription has been deleted.

With your advanced settings in place, click to Save the query and name it cancel_subscription.

Now, drag a button into the subscription card and configure it to trigger the cancel_subscription query:

• Edit the button's text to read Cancel Subscription
• Create an event handler that triggers the cancel_subscription query
• To improve the UX, disable the button if the subscription is already canceled by setting Disable when to {{table1.selectedRow.data.status === "canceled"}}
• Finally, make the button red to let the user know this is dangerous.

Now, see your full Super Subscription Center working by searching for a subscription, evaluating it, and then deleting it:

Next Steps

You now have an internal tool purpose built for your team to manage subscriptions!

With Retool, you didn't need to create a React application, worry about deployments, authentication, or even fuss with HTML, CSS, and boilerplate JavaScript. And with Sync Inc, you were able to pull in all your Stripe data in just a couple SQL queries. No need to created nested API call, deal with pagination, or fuss with client side search logic.

From here, you can continue to customize your app. Bring in data from your production database and join it to Stripe seamlessly (Sync Inc can put your Stripe data in your database). And of course, when you are ready, add your production API key to Sync Inc, change your resource in Retool, and start working with real customer subscriptions.

Low code and no code have equal amounts of hype and skepticism.

On the one hand, it’s clear low code has market traction: in April 2021, a provider of low code automation software, IPO’d at $31 billion. And Gartner predicts that by 2024, more than 65% of application development activity will come from low code application development platforms.

On the other, there is still developer skepticism: according to an Evans Data report, one in five developers never use low code. And anecdotally. And anecdotally, many developers express a similar sentiment:

Our thesis? Although low code may not be disrupting or replacing software development, it is definitely transforming it.

To that effect, we thought it’d be helpful to offer an overview of the low code landscape. We’ll dig into the basics, the controversies, and what we think the future holds. We’ll answer questions such as:

• What is low code?
• What’s the difference between low code and no code?
• What are the major use cases for low code?
• What are the benefits and drawbacks of low code?
• What does low code say about the future of software development?

This article is most useful for non-developers, but anyone interested in a primer is welcome.

What is low code? A primer

Low code is the development of software via a visual drag-and-drop interface. The logic is simple and the UI is intuitive; ideally, it offers possibilities for customizing the majority of components with code, but the idea is that most of the work can be done without spending time on writing custom code.

The three components of low code

A low code development platform consists of three major components.

1. A visual integrated development environment (IDE): This is the core of a low code development platform. It’s usually a drag-and-drop interface that developers use to model workflows and declare logic. They can also use it to add hand-written code. Typically, developers use the IDE to create most of the app, then customize the last mile with custom code.

2. Connectors: Depending on the low code platform, various kinds of connectors plug the platform into a variety of back-end services, databases, and APIs. These provide extensibility and increased functionality. Developers tend to prioritize connectors because the usefulness of a low code platform is directly tied to what it integrates with. Some early low code platforms are short on connection functionality, leaving developers with with unnecessary workarounds or missed requirements.

3. Application lifecycle manager: If a low-code platform promises robust results that match those produced by coding, then it needs to come with quality lifecycle management: tools for debugging, deployment, and maintenance of code across testing, staging, and production (necessary steps for building any app, no matter how you build it).

What does low code do?

The primary goal of low code is to reduce the amount of “hand-coding” (i.e., code done from scratch) and increase the amount of code reused and apps developed. Low code is highly composable, meaning that when you use the visual IDE to construct a component, it’s easy to then reuse that component in different situations.
The reason why it’s called “low code” (as opposed to “no code,” which we’ll get into in the next section) is that low code development is split roughly 80:20 between visual coding and  hand-coding. You build about 80% of your app using a low code UI, then hand-code the rest—usually last-mile specifications, as necessary.

In the below video, for instance, our developer advocate, Chris Smith, creates an internal tool app for managing sales inventory stored in MongoDB: a vast majority using Retool’s visual interface, then final customizations using in-line JavaScript.

Low code vs. no code: the differences and similarities

Let’s bust a myth right from the get-go: low code and no code are not the same thing. At a fundamental level, the technologies are different.

What is no code?

If low code is the minimization of hand-coding, then no code is the elimination of hand-coding.

No code also uses a visual workflow builder and IDE, but it doesn’t require developers to hand-code at all, a feature that poses both advantages and disadvantages.

At first glance, that difference seems minor. If anything, it seems advantageous for no code—why code a little when you could skip coding altogether? But it turns out that difference makes all the difference.

Low code vs. no code: the small differences

The first differences you’ll notice between low code and no code involve differences among target users, design, and UI. Though these differences aren’t minor, they make low code and no code applications look slightly different.

• Target user: Low code is for semi-technical business users and technical developers, whereas no code is just for business users. Since low code still involves some hand-coding, many low code tools still require software developers to either handle development or take it over the last mile.
• Design: Low code platforms still depend on hard code for software architecture, whereas no code tends to have model-driven workflows and declarative logic.
• UI: Low code provides greater flexibility, enabling developers to add hand-written code to visually developed components, whereas no code is a closed system that tends to lock users into the abilities of the no code platform in question. The ramifications of this lock-in vary depending on what platform you choose.

If these were the only differences, you could imagine low code and no code someday converging or a vendor offering a platform that effectively does both. This ignores the fact, however, that low code and no code are different at a fundamental level.

Low code vs. no code: the big difference

No code abstracts away code, whereas low code retains the ability to code. Though that difference might seem small on the surface, the ramifications are profound.

Low code is a natural extension of web frameworks, component libraries, and the long tradition of borrowing pre-built work and adding in nuances that are unique to your situation. Developers have always strived for more composability, and entire businesses have been built on this desire: think API-first companies like Twilio and package managers like npm.

Low code is less a disruption and more a continuation of this tradition. Low code helps developers move faster, both by helping them make decisions and follow through on actions more efficiently. That speed, however, doesn’t sacrifice anything—low code respects the fact that developers will still need to customize.

The ability to customize is a DNA-level difference, and it has ripple effects. No code aims at a new audience with a new proposal: turn all of the code into UIs, logic, and simple steps, such that non-technical business users (or “citizen developers”) can now “code.”

No code, by its very nature, is opinionated and inflexible. While both low code and no code manifest similarities (namely the drag-and-drop visual IDE mentioned above), they approach different problems and solve them so distinctly that the possible end results are entirely different.

5 low code use cases

Low code use cases range from the complex (such as full-on app development) to the relatively simple (such as landing page design).

1. Internal tools

Internal tools aren’t flashy, but developers spend a lot of time working on them. According to our research in The state of internal tools in 2021, developers spend nearly a third of their time (30%) building internal applications.

It’s not that this work isn’t impactful (it is; for companies with more than ten employees, one in three employees are using internal apps a developer has built). It’s that internal tools aren’t always how developers want to spend their time nor how businesses want to spend their development resources.

With low code platforms, you can develop internal tools faster and even enable some non-developers to build them, too.

2. UI design

Some low code platforms let you build an intuitive user interface from drag-and-drop components. This is especially useful for back-end developers who may have to build dashboards but aren’t familiar with UX best practices.

This use case bleeds into others on the list. A popular internal tool, for instance, is a sales dashboard that helps sales reps track deal flow. The sales team might ask a back-end developer to make such a tool, and while the back-end developer can easily handle the data, they might not be able to present that data in an intuitive way.

With low code, a back-end developer can easily spin up a UI that they can layer onto the data they retrieve.

3. Integration and automation

Platforms like UiPath, Workato, and Appian provide ways to integrate apps and automate the processes that connect and flow between them.

Many companies, large enterprises especially, are stuck with legacy infrastructure (think SAP, Oracle, Citrix) that they can’t afford to rip out and replace. These companies, however, are increasingly feeling the heat from nimble startups relying on custom-built tools, SaaS apps, and APIs.

With low code, enterprises can achieve some of that speed by connecting and automating those legacy systems. Enterprises can then adjust and iterate much like startups can, leaving them less vulnerable to disruption.

4. Basic app development

Low code tools like Bubble.io enable non-developers to spin up entire web apps, and low code tools like Memberful enable non-developers to add specific features to their apps (in Memberful’s case, membership).

Some of the results of Bubble.io, according to their showcase page, include:

• Teeming, a cloud-based tool that helps remote teams bond via interactive work sessions
• ResidentStreet, a platform that connects people looking for “mid-term accommodations” (1-11 months) with furnished properties
• Incomee, an accounting tool for freelancers

This use case is one where the difference between low code and no code really matters. Be aware of the customization limitations of no code as your app scales.

5. MVPs and prototypes

The minimum viable product (MVP) methodology, originating with famed startup expert Eric Ries, asks developers and startups to ship products faster, get feedback earlier, and build with customers in mind. MVPs (and prototypes, a similar idea) are a great use case for low code.

The idea is this: don’t invest tons of development resources into an app or feature you’re unsure of. When you’re building an app from scratch, the necessary up-front investment is immense. You have to think about hosting, the back-end, the front-end, the UI, maintenance, monitoring analytics… the list goes on.

Those are all distractions from what your primary focus needs to be at this early stage: your user and what they need. Low code helps you delay those important business decisions, so that you can make them later, when you have a stable business and customer traction.

With low code, you can get most of the way toward your final product, test it with your customers, and then, and only then, make an investment you’re confident in.

Why low code? Benefits and drawbacks

Low code has a variety of benefits and drawbacks, all of which depend on which low code platform(s) you choose and how you use it.

Low code benefits

Though low code comes with many benefits, they generally come down to three core ones.

Increase time to value (TTV)

Compared to hand-coding, low code development gets developers from idea to execution to production much faster.

According to Kintone research, developers using low code tools “get applications out the door faster than large IT departments. They turn around their required applications in a matter of weeks, or a couple of months. Only 17% report turnaround times exceeding three months.”

Improve developer productivity and efficiency

Many low code platforms come with pre-built components, and most come with the ability to make components you can reuse, making low code development eminently composable. Developers can borrow, build, and reuse components as they go, making them more efficient over time.

Improved productivity and efficiency is backed up by research, both in terms of sheer speed and the ability to meet previously unmet demand via improved efficiency:

• Forrester analyst John Rymer says that low code platforms “have the potential to make software development as much as 10 times faster than traditional methods.”
• Caspio research shows that 63% of organizations using low code platforms have the skills and resources to fulfill the demand for custom apps, whereas only 41% of organizations not using low code can say the same. Similarly, 61% (as opposed to 38%) of organizations using low code typically deliver custom apps on time, on scope, and on budget.

With low code, developers can ship faster.

Better use of existing staff

Developers are in short supply.

According to the Bureau of Labor Statistics, “employment of software developers...is projected to grow 22% from 2019 to 2029, much faster than the average for all occupations.” Demand for software developers is already outpacing supply, despite the ever-increasing need for software. This is backed up by TechRepublic research, which found that 83% of CIOs struggle to find tech talent.

Low code allows already hired developers to move faster (as covered in the previous benefit), but it also allows non-developers, such as operations staff, to take part in development. Companies can produce more software with existing staff.

Drawbacks

Low code isn’t without its drawbacks, but you can defeat many of these by choosing a modern low code platform that fits your use case.

Vendor lock-in

Perhaps the top reason developers fear low code tools is the risk of vendor lock-in. Whereas hand-coding is inherently flexible and extensible, low code platforms have the potential to lock developers into a limited ecosystem.

This drawback varies depending on which low code platform you choose. Legacy low code application development platforms, many of which resemble no code more than low code, can absolutely lock you into their ecosystems. Modern low code platforms, however, tend to be built on the aforementioned tradition of composability, meaning that there’s an inherent respect for the need to customize.

Retool, for instance, is built on Javascript and SQL, meaning developers versed in those languages can easily add on to what they develop in Retool.

Shadow IT and governance

IT might be resistant to low code adoption.

According to Jason Bloomberg, an IT industry analyst, “IT has been telling business stakeholders for years that the six month/million dollar plan is the only way to build enterprise software,” but now, according to Simon Chan, Founder and CEO of DigiVue Consulting, “the same systems can be implemented by smaller players at a fraction of the price and in a fraction of the time,” which “has leveled the playing field.”

What might appear to be a level playing field to a business user, however, can appear to be a threat to IT. IT has long had to resist the encroachment of so-called “shadow IT,” and a low code program might appear to add fuel to that fire. Imagine, the IT admin might fear, if employees were not only adopting SaaS tools without permission but were building apps without permission?

This isn’t IT being controlling. There are serious ramifications, especially in terms of security, from letting more people build software. And they’re not wrong — according to Kintone research, more than one in four surveyed organizations have no citizen development policy of any kind in place. The problem is less with low code itself and more with how companies implement and scale low code programs. Eventually, governance becomes necessary.

Scalability

Some developers have an instinctual resistance to low code platforms based on the assumption that any code that isn’t hand-written can’t be robust enough to scale. This assumption isn’t true—low code apps can scale to enterprise proportions—but the nugget of truth is that many low code platforms aren’t built with scale in mind.

OutSystems, for instance, in a surprising moment of vendor honesty, notes that “When it’s time to scale, integrate with existing systems, or perform under extreme conditions like a mobile banking app on Black Friday, the [low code] application could buckle under the weight of functional and nonfunctional requirements. If an application built with low-code needs updating or if the underlying technology needs changing, good luck.”

The solution here tends to be picking a low code platform that can develop apps that can scale. And scalability tends to come from leaning into low code’s advantages. No code apps are much more likely to suffer from scalability problems because they aren’t customized. Use low code to build your foundation but hand-code your way to scalability.

How low code will shape the future of software development

Low code development will not replace traditional software development. Full stop. But it will change software development—and in some areas, the change will be dramatic.

Low code will add (more) abstraction

Low code, understood historically, is another layer of abstraction between developer and code.

You can trace the roots of low code back to the fourth-generation programming languages (think Visual Basic and PowerBuilder) and computer-aided software engineering (CASE), rapid application development (RAD), and business process management (BPM) tools from the 1990s. These early tools and platforms tried to fulfill the same promise modern low code does: build real apps in less time and with less code.

It took another couple of decades for the brand name to form, however. The first popular instance of the phrase “low code” occurred in a 2014 Forrester report and has been on a steady rise since.

Searches for “low-code app development platform” on Google Trends

If you want to get technical, you can trace low code back through the history of code, too. The history of code is itself a history of abstraction: every programming language is a more human-readable version of binary code. What’s unreadable to us now, like FORTRAN, was a big step toward readability back in the day. As Nacho Iacovino, developer advocate at Clerk, wrote in a guest post for us, even modern options like React are “a low(er)-code option, compared with the alternative of vanilla JavaScript which would take many more lines of code to achieve the same results.”

In the same way, low code is another step toward readability and up the ladder of abstraction. Viewed this way, low code isn’t a departure from history so much as it is a continuation.

Low code will add, not disrupt

A major reason developers are skeptical of low code is the hype. A simple Google search reveals the scale of the hype. “Is low code the future” returns over 2 million results, and articles on the topic include titles like:

• Why Low-Code Automation Is The Tech Of The Future
• Why low-code and no-code are the future of enterprise applications
• The Future of Software is No Code and Low Code Programming
• Low Code Is The Future Of Application Development
• Low-code programming – the next frontier in app development

Realistically, low code isn’t the future; it’s part of the future. Internal tool development, our specialty, provides a perfect example.

Internal tool development (which developers spend 30% of their time doing) is an ideal use for low code. Though two out of three developers default to building from scratch (instead of using a spreadsheet or a SaaS tool), 88% of developers that do build internal apps using low code plan to keep building that way in the future. In other words, most developers have a need that low code solves for but aren’t using low code—but once they try low code, they keep using it.

More than likely, low code won’t disrupt, displace, or destroy software development. Instead, developers will try particular low code tools, especially ones specialized for specific use cases, and replace hand-coding development when it benefits them to do so.

Low code will expand the circle of software development

According to Scott Brinker, VP of Platform Ecosystem at HubSpot, the best way to think of low code is to think of it as a way to expand the circle of people who can develop software.

Low code, as well as no code, enables more people to build software. This bears out in the research so far. According to Kintone research, many non-IT low code developers are power users “embedded within line-of-business departments building the applications.”

Power users are becoming more powerful, so powerful that they can now develop software. According to John Rymer, an analyst at Forrester, he can “see maybe 100 million people—business people—engaged in producing software.”

That means that companies don’t need to hire software developers for every software need. That doesn’t mean that developer hiring will slow, but that companies can reallocate developer hiring away from some projects (say, internal tool development) and toward customer-facing features as well as complex and unique software development problems.

The impact of low code on startups and enterprises

Often lost in the discussion of low code and its effects is context: low code looks very different to startups and enterprises.

Low code and startups

Startups are time- and resource-strapped, which is the primary reason they adopt low code tools. With low code, their existing engineers can move faster and make a greater impact in three primary ways.

Internal tools will be easier to make

With low code tools, developers can re-focus from internal tool development toward customer-facing features. For startups, who may only have a couple of developers, this time and effort are precious. With product-market fit still on the horizon, early-stage startups need as many engineering resources as possible dedicated to iteration.

Back-end developers will be able to develop better services

Back-end developers are well-versed in systems and functionality but not in UX design. With low code, even back-end developers can create pretty, intuitive apps and tools. The ever-elusive 10x full-stack developer becomes more attainable if you can enable back-end developers to create things only a front-end developer would normally be able to make.

Validation will come sooner in a startup’s life

As we covered above, low code enables companies to rapidly build MVPs and prototypes. This is especially useful for startups, who may still be settling on a product and pursuing product-market fit. The right low code tool will also enable rapid iteration, such that startups can debut and improve products before dedicating much in the way of hand-coding.

Curtis Cummings, a Senior Software Engineer at On Deck, said in an interview he did with Retool, “I’ve been on a couple of different projects in my consulting career where we had this perfect spec, we built it perfectly to spec, went out to users and it fell flat on its face because all the assumptions that backed up that spec weren’t validated or grounded in user data.”

With low code, startups are less likely to fall on their faces.

Low code and enterprises

Enterprises are not, generally, in want of resources like startups are, but they are often stuck with technical debt.

Enterprise technical debt, driven by prior investments in now legacy technologies, is encouraging many enterprises to adopt low code and pursue modernization. There are three primary use cases for enterprises and low code.

Improved agility

Low code tools, especially those from the RPA and workflow automation fields, will enable enterprises to move more nimbly. Enterprise technology stacks are often overly complex, old, and slow. Low code automation tools can reduce the negative effects of that complexity. These tools can automate the steps involved in the processes these legacy tools run.

Software robots, offered by low code RPA tools, for instance, can run unattended, meaning they can operate in the background, 24/7, handling all the agonizingly manual processes legacy tools typically require.

Modernize and connect legacy technology

Enterprises are not only stuck with legacy technology; those legacy technologies are themselves often stuck in disparate silos. Connecting your ERPs to your CRMs and back again, for instance, can be a nightmare. Enterprises often face the choice of either living with it and being inefficient or hiring armies of consultants to fix it all, which is expensive.

With low code, enterprises can modernize their legacy technology stacks without ripping them out and replacing them. Low code tools can layer on top of these tools and create a much more usable, intuitive interface. Business users can then access and use systems they previously would have had to request help from developers to use.

Digital transformation

Forgive the buzzword, but for enterprises, digital transformation is a serious pursuit. Many enterprises are still operating on paper and, if not paper, so-called “digital paper” systems — technologies that weren’t designed with the internet and native digital capabilities in mind.

In clinical research, for example, as product manager Stephanie Morillo points out in this Twitter thread, many organizations still use Excel. Rather than use a modern database tool, enterprises (and their employees) use a tool that lacks version control and can’t handle the thousands of rows necessary for their purposes.

If ever there was a need for low code, this is it.

Low code is in your future (even if it isn’t the future)

Big brain, hot take “thought leadership” on low code often relies on the phrase “the future of,” as if software development — an already complex and diverse field of technologies and methodologies — will somehow evolve into one, simple thing. Well, it won’t. That doesn’t mean, however, that low code won’t create incredible change.

Low code will transform the field of software development by empowering developers to choose when and where they want to spend time hand-coding. With low code, developers can build less and architect more. As more developers adopt low code, the industry will shift in big, unpredictable ways.

Full-time developers, armed with low code (or arming business users with low code), can re-focus from solving simple problems to solving complex problems. The effect of this reallocation is hard to understate and hard to predict. Developers run the world these days (see Stripe, Twilio, Atlassian, Datadog, MongoDB, etc.), so imagine if these kingmakers shifted their internal tool development efforts (30% of their time) toward changing the world. And that’s only one use case for low code!

MongoDB is a NoSQL database that more than a quarter of developers use in some capacity. What makes MongoDB and other NoSQL DBs attractive is flexibility; instead of being held to a rigid schema that scales vertically, you can evolve your schema as you grow and scale horizontally. MongoDB went public in 2017 and is worth more than $17 billion today.

Document DBs work through nested key-value pairs instead of relational tables and columns. You’re going to need to parse data for your front-end eventually, and with document DBs, your data is already stored in the right format (give or take a .map or .reduce). Working with MongoDB through the command line isn’t exactly a cakewalk: This post will walk through the best MongoDB GUIs available for reading from and writing to your MongoDB clusters.

The Mongo Shell Versus a MongoDB GUI

The most basic way to access MongoDB is through the mongo shell; you can use it to query, update data, and complete admin tasks.

It’s included in the MongoDB Server installation, so you’re all set as long as you’re comfortable with shell commands. Traversing objects and writing long queries in the command line can get annoying fast, so using the shell is usually best for quick peeks or admin tasks.

> use sample_analytics
    switched to db sample_analytics
> db.transactions.find({})
   {
   "_id": "5ca4bbc7a2dd94ee581625eb",
   "account_id": 50948,
   "limit": 10000,
   "products": [
     "InvestmentStock",
     "Commodity",
     "Brokerage"
   ],
   "transaction_info": [
     {
       "_id": "5ca4bbc1a2dd94ee58161e14",
       "account_id": 50948,
       "transaction_count": 6,
       "bucket_start_date": "1991-05-08T00:00:00.000Z",
       "bucket_end_date": "2015-10-13T00:00:00.000Z",
       "transactions": [
         {
           "date": "2015-10-08T00:00:00.000Z",
           "amount": 2311,
           "transaction_code": "sell",
           "symbol": "nflx",
           "price": "104.9154457571513461289214319549500942230224609375",
           "total": "242459.5951447767609039374292"
         },
         {
           "date": "1995-12-15T00:00:00.000Z",
           "amount": 4828,
           "transaction_code": "buy",
           "symbol": "aapl",
           "price": "1.102632231847472166208490307326428592205047607421875",
           "total": "5323.508415359595618454591204"
         },
         ...
       ]
     }
   ]
 },

It’s definitely possible to query your Mongo data exclusively from the command line, but if you’re working with even medium-sized datasets, GUIs offer a helpful alternative.

MongoDB GUIs provide a user interface for your MongoDB database that gives you the ability to visualize data and edit queries without the use of shell commands (or with them — more on that later).

The best MongoDB GUIs share similar features:

• A visual query editor: Click or drag-and-drop elements to create queries.
• Query autocomplete: Auto-suggestions for collections, fields, methods, and operators.
• An aggregation framework: Build queries out step-by-step, test along the way, then export into usable code.
• Server and query analytics: Insights into query and server performance.
• Relational database to MongoDB data transfer: Automate tedious and error-prone data transfers between database types.

Below is a list of the best MongoDB GUIs that 2021 has to offer. Each one has features that set it apart from the rest. The best one for you will depend on the scope of your project, the features you need, and your budget.

MongoDB Compass

(Image courtesy of MongoDB Compass GitHub Repository)

Overview

The creators of MongoDB (Mongo) have their own GUI called Compass. It’s platform-agnostic and provides a graphical view of your database without the need to use a query language. MongoDB recently announced that the fully featured Compass GUI is completely free for everyone to use. Plus, the repo is now open-source on GitHub.

Some notable MongoDB Compass features include:

• Schema visualization: Compass visually displays your collections to help you better understand your datasets.
• CRUD visual editor: Perform CRUD operations within the UI, no need to type queries.
• Geospatial data: Create queries on map data using an intuitive UI with generated results in both graph and JSON document form.
• Validation: Write JSON Schema validation rules using an editor that suggests BSON data types and validation keywords as you write

Winning feature: Compass Plugins

One of the best features of the MongoDB Compass GUI is that it has an API for adding plugins. The Compass community has built tons of cool plugins that can generate data for testing, inspect database users, and even check the shard status of the database. If there’s a feature you want but a plugin isn’t available yet, you can build your own using their plugin template.

TablePlus

(Image courtesy of TablePlus)

Overview

TablePlus is a modern, native GUI tool for relational databases like MySQL, PostgreSQL, SQLite, and NoSQL databases like MongoDB. The TablePlus team consists of founder Henry Pham and Windows developer Raccoon Thai. The team, as well as the community, is also fairly active on GitHub.

Some notable TablePlus features include:

• Customizable UI: There’s no need to turn to Mojave. With TablePlus, you can customize your configurations and their appearance
• In-line edits: Edit data rows and table structure with a single click

Winning feature: database security

TablePlus promises secure connections. The connection between you and your database is end-to-end encrypted –– no data is sent to a TablePlus server. Additionally, TablePlus ensures database credentials are stored securely in your device’s keychain and comes with built-in SSH. TablePlus also supports multi-step authentication and native libssh.

Robo 3T

(Photo courtesy of Robo 3T blog)

Overview

Robo 3T is an open-source, platform-agnostic, lightweight GUI for MongoDB. Formerly known as Robomongo, the company was bought in 2017 by 3T Software Labs and rebranded (Robo 3T also made it open source).

The project continues to be developed and has 8K stars on Github. In that vein, one of the best parts of using this GUI is the large community of users. Loads of tutorials, guides, and forums are available if you get stuck – just search.

Some notable Robo 3T features include:

• Code autocomplete: While Robo 3T doesn’t have the autocompleting prowess of IntelliShell (see Studio 3T below), it does have a useful runtime autocomplete feature that works through an internal virtual machine.
• Fast UI: All operations are done asynchronously, which means the application will never block you from working by freezing up.

Winning feature: embedded Mongodb shell

Many of the MongoDB GUIs have emulated mongo shells, but this GUI has an embedded mongo shell. The embedded shell provides increased functionality over an emulated shell because emulators generally run on top of a provided API, whereas an embedded shell works directly with MongoDB.

Studio 3T

(Photo courtesy of Studio 3T)

Overview

Studio 3T, formerly MongoChef, is the robust, professional version of Robo 3T owned by the same parent company, 3T Software Labs. Studio 3T is more than just a MongoDB GUI: it’s also an IDE and client. There is no free version of this software (unless you count Robo 3T), and the Core pricing level starts at $149/year per user. Even then, the Core level lacks features that pricier ones have, like SQL import/export, SQL queries, and the schema explorer.

Some notable Studio 3T features include:

• IntelliShell: A smart, built-in mongo shell with autocomplete that supports Javascript standard library functions, collection and field names, operators, and methods.
• Three ways to view data: Once you have retrieved your data from the database, you can view it in three different formats:
  • Table View formats the data into rows and columns.
  • Tree View formats the data into expandable hierarchies.
  • JSON View formats your data as JSON documents.
• Code generation: Export queries into Node.js, Python, Java, C#, PHP, Ruby, or the mongo shell language.
• Data import: Support for data imports from SQL databases, Oracle, and Sybase.

Winning feature: four ways to query MongoDB and view data

Out of all MongoDB GUIs, Studio 3T provides the most ways to query your database. You can query using:

1. SQL queries: Query MongoDB using the SQL query language (super cool!)
2. The mongo shell: Built-in IntelliShell technology that provides robust autocomplete features
3. The Aggregation Editor: For building up complicated queries
4. The Visual Query Builder: A drag-and-drop editor for building out queries (fun fact: can be used side-by-side with IntelliShell)

Given this volume of query methods (including less “technical” ones), Studio 3T is usable for anyone, no matter their familiarity with document-based databases, query languages, or command lines.

NoSQLBooster

Overview

NoSQLBooster is a shell-centric GUI with a broad range of features that come with a paid license. The free tier is missing many of the features that make this GUI so great, like code completion and the visual query builder. NoSQLBooster does not work through a subscription model, so once you pay for a license, it’s yours forever (or until you want to update your version).

Some notable NoSQLBooster features include:

• IntelliSense: Similar to Studio 3T’s IntelliShell, this language service appears as a tooltip while you type to suggest completions, methods, properties, variables, keywords, collection names, field names, and operators.
• Interactive samples: In-app tutorials with prewritten queries and descriptions for learning how to use MongoDB.

A notable part of IntelliSense is the built-in snippets that offer code completion for operations like SQL to MongoDB data conversions and date ranges. You can also create your own snippets to save time.

Winning feature: NPM packages in the MongoDB shell script

The best feature of NoSQLBooster is the unique ability to add any NPM package into the MongoDB shell script. In fact, this GUI already comes with a number of useful and popular utility modules — like lodash, moment, bluebird, ShellJS, and math.js — in the global scope, ready to use.

HumongouS.io

(Image courtesy of HumongouS.io)

Overview

HumongouS.io is a fully online MongoDB GUI. Since it’s online, HumongouS.io allows users to collaborate pretty seamlessly. Instead of using it as just a GUI, you can set it up as a more fully-featured internal admin tool. You then don’t need to share database credentials but can instead invite people to collaborate with you from the app. You can even access your data on a mobile device.

Some notable features include:

• Smart filters: Create filters that you can use to display your collections as chips, which enables quick access
• Charts and dashboards: Easily create charts and dashboards to track the metrics that are important to you

Winning feature: widgets for customization

With HumongouS.io widgets, you can customize how your data displays and use those widgets to pull data from specific reference collections as needed. There are viewer, form, and layout widgets. Viewer widgets let you represent data in more meaningful ways than default string values.

Form widgets are, according to HumongouS.io’s documentation, “the building blocks of forms.” They’re also customizable, meaning you can match them to any data type in your database.

Layout widgets give you an alternative to the default table view, allowing you to display specialized data.

NoSQL Manager

(Image courtesy of NoSQL Manager)

Overview

NoSQL Manager is a shell-based MongoDB GUI tool. NoSQL Manager makes it easy to navigate, view, and edit documents, as well as set limits to maximize performance. You can manage, as the name implies, a lot of things, including collections and their indices as well as users, roles, and functions. It offers support for MongoDB Enterprise, MongoDB on Azure Cosmos DB, and Amazon DocumentDB.

Some notable features include:

• Wide support: NoSQL Manager supports replica sets, sharded clusters connections, and standalone hosts
• Document viewer: The NoSQL Manager document viewer and editor offer Tree, Table, and JSON view modes
• SSH tunneling: NoSQL Manager offers SSH tunneling for MongoDB connections
• Imports: Import tables from your MySQL and SQL Server databases

Winning feature: autocompletion

NoSQL Manager comes with a MongoDB UI Shell that offers code autocompletion, syntax highlighting, and hints. Autocompletion takes much of the guesswork out of MongoDB management, helping you by autocompleting things like the collection names and methods in MongoDB Shell commands. As you type into the Shell, NoSQL Manager uses context clues to provide collection or method completion.

Bonus: Retool

Overview

Retool is a low code app builder where you can build any GUI for MongoDB (see template). Retool makes it possible to drag-and-drop visual components to avoid boilerplate code and connect to anything with a REST or GraphQL API, meaning you can build a full-featured MongoDB GUI—and include any CRUD operations—in just a few hours.

Some notable Retool features include:

• Speed: Connecting Retool to MongoDB takes just a few minutes
• Schema inspection: Visually view your data.
• Save and share queries: Keep your queries handy for multiple uses.
• Turn your queries into useful tools: go from query to table, search, and button without writing frontend code.

Winning feature: Customizable front end for visualizing data

You can use Retool’s pre-built components—including tables, buttons, text inputs, and search bars—to not only view your data but do any CRUD operations you need to keep your business going. Once you connect your data sources, you design your frontend with their drag-and-drop component tool.

The Best MongoDB GUI for Your Project

As with any tool, the best MongoDB GUI for you depends on what you’re trying to accomplish.

If you want to completely avoid the command line, MongoDB’s Compass is probably the most fully featured and natively integrated GUI out there. If you want a simple application that has a well-supported community, Robo 3T is the best GUI. If you’re familiar with SQL and want to keep writing queries in everyone’s favorite query language™, NoSQLBooster is going to feel slick. If you’re looking to easily share queries or turn your queries into tools, check out Retool.

Processing sensitive data using SaaS products, especially in regulated spaces, can be a challenge. Data is often moved or stored through the vendor’s cloud, which can be a non-starter or lead to endless security reviews.

To help developers build business apps safely, we offer a variety of self-hosted Retool plans. But selling self-hosted software means our team needs a way to create, issue, manage, renew, and deactivate license keys for every customer.

In the early days, our engineers would run a simple script to manage self-hosted licenses. With fewer customers and features, it was an easy MVP. But as the number of self-hosted customers grew and our product became more complex, we needed a way to make this more scalable.

It started with giving account teams more control over user licensing. To do this, we needed to move away from our error-prone scripts to a more complete app that business users could own. This is the story behind our Account Team Dashboard and how Retool now manages user licenses.

Introducing the Account Team Dashboard

Over the last 9 months, we’ve added thousands of new customers and have grown the team from 15 to over 80. Even with a lot of new engineering teammates, our go-to-market team (i.e. success, support, sales, etc.) is expanding fast and is starting to outgrow a lot of our early processes.

The account teams want to deliver a winning user experience, but that can be difficult to ensure when they don’t control the entire user setup flow. No matter how fast our engineers could move, we wanted to move away from any dependencies to make the account team self-sufficient.

So we built the Account Team Dashboard as a central system for account teams to manage customer licenses.

Our dashboard has 4 key use cases:

1. Generating license keys for new and trial accounts
2. Extending trials and renewing licenses
3. Mapping Salesforce accounts to license keys
4. Enabling custom feature flags for customers

Generating license keys

First and foremost, we need a quick way to generate license keys for new accounts and self-hosted trials. Our dashboard has a simple two-step process generate a license key and manage everything from expiration date to license type (reminder: we have several self-hosted plan options).

Extending trials and renewing licenses

At the same time, we also wanted account teams to have 1-click options to renew customer licenses and extend licenses to custom dates. With all of these functions in the same dashboard, we created one place to manage trials, new accounts, and renewals.

Mapping Salesforce accounts to license keys

We also wanted to ensure this dashboard and Salesforce (our source of truth for account info) were able to read and write data to each other. One critical detail was ensuring there was a 1:1 mapping between the license keys in our database with Salesforce accounts.

By building this visibility and editing into our dashboard, we’ve empowered account teams to discover data discrepancies and solve them in seconds.

Enabling custom feature flags for customers

Finally, we’re making updates to Retool on a daily basis, but not every feature is relevant or ready for every customer.

When features are in early development or beta, we want account teams to be able to communicate and align with customers on whether they want or need the feature. Once they have more information, account teams can quickly toggle any feature flag on or off for the customer.

How we built the dashboard

This app needs to communicate with a few key data sources:

• Salesforce
• Our management database
• Our separate licensing database
• Our licensing API

In terms of actually building the dashboard, the first step was pulling new accounts or trial accounts from Salesforce into our management database. We achieved this by creating a simple search bar.

Once you find the company in the table below, you can click a button to add the company to our management database. The button triggers a Postgres query, which does an insert into our companies table.

Once a company has been added to our management database, we can generate a “deployment” for them. To generate a deployment, need a few things: a unique license key, an expiration date, a type, and a domain.

The tool handles the creation of a unique license key by triggering a Javascript query off of a button click. The other inputs for this deployment are a date picker, dropdown, and text input. These are all contained within a form (see below). Submitting the form runs a Postgres query which inserts a new record into a deployments table.

Once a license key has been created, the app offers a few quick actions: setting a custom expiration date, deleting the key, and adding a week to the expiration date of the key. These buttons all trigger Postgres queries which update the deployment based on the selected row of the table displaying these keys.

We also provide functionality to copy the key to the clipboard, as well as copy the key as base64. When deploying via Kubernetes, license keys needed to be base64 encoded. We were seeing a lot of errors with people encoding these keys with whitespace, so we added a button that base64 encodes the key correctly and copies it to the clipboard.

Results

Our Account Team Dashboard has reduced dependencies between engineering and our account teams but, more importantly, the tool has become a core part of our workflow.

With our Account Team Dashboard, I can create a smooth customer experience without waiting on engineers or double-checking whether a script ran the way it was supposed to. I can’t imagine managing customer deployments without this dashboard.
Kent Walters, AE

The alternative of running scripts and editing the database directly couldn’t scale and slowed down the entire team. This new process gives the account teams total control over the customer experience and engineers more time to focus on core product updates.

When evaluating just the impact of just our Kubernetes base64 encoding feature, the team found we saved 4 hours per week on debugging and customer calls—and that’s one tiny feature of the dashboard!

When you add up all of the different dependencies we’ve removed and processes we’ve sped up, we’re saving dozens of hours a month and giving customers a blazing fast onboarding and renewal experience.

If you’re interested in building your own dashboard, get started with Retool today.

Let’s face it: most modern applications and websites feature a map in some form. This could be as simple as displaying a company’s address or as complex as identifying stock levels by store location.

While simple maps don’t require a library to include in your React application (a simple iFrame or widget embed will do the trick there!), it's vital to understand what options exist for building more complex mapping applications.

This article wades through the myriad of mapping libraries out there and narrows the best options to two contenders. We break down the strengths and drawbacks of the top React map libraries, as well as highlight the types of projects each library excels at so you can determine which React mapping library is best for you and your needs.

Why Google-map-react and react-leaflet are our top choices for React map libraries

A great place to start when considering a React library is npm trends. This site allows you to quickly compare important statistics on each library, such as the number of downloads, stars, last-updated date, and file size.

We used npm trends to compare five of the most popular React mapping libraries, and the top ones are:

• Google-map-react
• Pigeon-maps
• React-leaflet
• React-map-gl
• React-mapbox-gl

Looking at the npm trends of these five libraries, we see that google-map-react and react-leaflet have steadily had more downloads per month for the past six months than any of the other libraries.

While the number of downloads is a great initial indicator, that alone is hardly a good reason to choose a library. In fact, as we look at the rest of the information on npm trends, we see that react-map-gl actually ranks higher than react-leaflet in stars. This is a good general indicator of popularity since developers can “star” a package to show they have interest in it.

So, how did we use this information to determine that google-map-react and react-leaflet were the two best mapping libraries? The simple answer is we didn’t use this information alone.

To really know which library is going to best meet our needs, we have to go beyond a simple comparison website like npm trends and dive a bit deeper into what these libraries can do for us. We took the time to learn more about each library so we could determine which was best.

We recommend google-map-react and react-leaflet because, between the two of them, they cover a broad range of use-cases, and they are both easy to use and well-documented.

Google-map-react easily gets marker-based mapping apps up and running

If your project allows you to use the Google Maps API, then google-map-react provides easy access to many of the common features you already know from that API while giving you the flexibility to implement custom markers with all the benefits of React. With just a few lines of code, you’re up and running!

The google-map-react documentation supplements the regular Google Maps API documentation nicely. One especially great feature of the google-map-react documentation is the included editable JSbin. This makes it easy to start experimenting with what is possible.

When you’re ready to check out a more complex example, we recommend this sample app from their documentation that covers a lot of functionality. To see the code behind that application, simply click on the “source” link at the top of the page.

Since google-map-react utilizes the Google Maps API, you will eventually need to get an API key. If you’re just looking to test out google-map-react, you’re able to get started without one. You can learn more about Google’s API as well as the pricing structure on Google Cloud. Google has a generous free tier for API usage, though if your site gets a lot of traffic, you might wind up needing to pay.

react-leaflet is the most versatile mapping library available

While google-map-react is good if you want to use the Google Maps API, one of the great things about react-leaflet is that you aren’t bound to any particular mapping service. If you want to use an open-source solution like OpenStreetMap it integrates seamlessly. Or if a full-featured proprietary solution like Mapbox is what you’re looking for, that works just as well.

React-leaflet is extremely versatile, which is a clear strength of the library, but it can also be a little intimidating to get started with. This is where react-leaflet’s excellent documentation comes in. It walks you step-by-step through how to get started and then provides well-organized examples of the variety of things you can do with the library. The examples come with a live editor, so you can easily start playing with code right in your browser. For example, if you want to know how to add vector layers to your map, simply check out the live vector layer example.

The possibilities of what you can build with react-leaflet are endless, and the react-leaflet documentation makes it easy to explore them. Rendering markers, adding geoJSON, and interacting with tooltips are just a few examples of what’s possible with react-leaflet!

Other effective options for React map libraries

While react-leaflet and google-map-react are by far our favorite React libraries, there are a couple of others worth mentioning:

• React-map-gl provides a library of React components that work with mapbox GL libraries. Their documentation isn’t as strong as react-leaflet’s, but if you want to use mapbox GL, it could be a great way to go.
• Pigeon-maps is a small library that caught our eye because it doesn’t have any external dependencies, which is always nice. It has a lot of stars on NPM trends, but the number of downloads was quite small, which we consider a bit of a warning sign. That said, it’s definitely a library worth keeping your eye on, and if a small dependency-free library is what you’re looking for, it might be worth trying out.

Lean on the right React map library to make your next project simple

Rather than sifting through the wealth of React map library alternatives to experiment and find the best option yourself for your next project, we’ve done the legwork for you.

Leveraging quality React map libraries like react-leaflet and google-map-react makes it easier to add a wide range of mapping functionality into your React application. React map libraries make it easy to incorporate maps into React’s virtual DOM. You can’t go wrong with a robust, well-documented solution like react-leaflet. Or, if you want to take advantage of Google’s mapping expertise and excellent API google-map-react makes it easy to do so.