Internal tools are essential to the success of a business.
However, one of the troublesome aspects of internal tooling is that they are inherently custom. The real world is a messy place, and the best tools accommodate for the peculiarities of your startup. Often the tools needed are simple, but not worth the on-going maintenance burden of code.
It’s also suboptimal to purchase one-size-fits-all solutions available off-the-shelf for every use case. Not to mention, this approach is expensive, especially early-on in a startup’s lifecycle when iteration speed is paramount. Costs can quickly add up with monthly subscriptions and per-seat licenses.
Early on, we made a bet that Retool would enable our organization to grow and scale our internal tool infrastructure. That bet is paying off. We can iterate on new features faster while writing less code, all while improving long-term maintainability.
What follows is an in-depth look into how we built internal tools at Zebra to power our creator community platform. Feel free to use this as a template for your own organization.
Sections:
- Core KPIs & Executive Dashboards
- Growth Dashboards (e.g. US State Coverage)
- DevOps Dashboard (tracking operational metrics, deployments, and releases)
- Customer Support & Lookup Tools
- Review Queue Dashboards (eg. payouts, survey response moderation)
- Testing Tools
1. Core KPIs & Executive Dashboards
We use Retool as a “dashboard of dashboards” for our internal team metrics.
At Zebra, we track our top-level KPIs like Monthly Active Users so everyone on the team can easily access it. Here, we directly integrated with the Amplitude API.
We also have shared a selective dashboard for potential investors in the past.
2. Growth Dashboards
Other dashboards provide the our team visibility into the status of our user-base, making it easier for us to identify opportunities for growth.
The growth team tracks their numbers over time across bespoke dashboards that have rich filtering and formatting controls.
As an example, if I wanted to explore the breakdown of users by US state, we could build a tool to query our pseudonymized user object, retrieve a “state” attribute, aggregate over that attribute, and display a table of that data.
3. DevOps Dashboard
For tracking operational metrics, deployments, and releases, we use a rich series of DevOps dashboards — all built in Retool.
One frequently used tool is our Deployer. The Deployer allows any authorized developer in the company to deploy code to our staging and production clusters. Other teams I’ve been on have used Slackbots, but we prefer a rich, customizable UI for managing our deploys.
The process for deploying a new version of a feature typically goes something like this:
- Someone finishes a feature and submits a PR.
- Using our Deployer tool, we deploy the feature branch to our staging environment.
- The Deployer creates a GitHub Deployment, that triggers a GitHub Action, that performs the actual deployment.
- Our QA team tests the new feature. If QA finds issues, the reviewer can make changes to the PR.
- When QA is done, the reviewer will approve the PR.
- We deploy from the main branch to our production environment using the Deployer tool.
Our deployment process for iOS and Android apps is similar, and is instrumented via fastlane.
We support a few advanced features, too. For example, environment locks warn users not to deploy to an environment for a stated reason (e.g. because testing is on-going).
4. Customer Support & Lookup Tools
It’s often necessary to look up an object in your database, even if that object isn’t exposed to the public.
For example, our customer support team often needs to access some part of the user’s account to help the user in addressing a request (e.g. cancelling a pending payout).
Also, as a developer, when I’m debugging a piece of code, I may want to see how many times an event is recorded on our internal admin API.
With Retool, I usually end up with about one dashboard per domain object. When I have more than one, it’s often because the object has alternative views based on the user’s role or intended function.
In the spirit of “Command-Query Separation”, we separate many of the dashboards that perform lookup functionality from the tools that perform specific actions. That way, we can permission each of the dashboards independently per user group with granularity. We can also limit the information displayed to what is necessary for the task at hand.
5. Review Queue Dashboards
We have a handful of queues that our internal operation team maintains. We’ve built custom dashboards for each of these pipelines. For example, we built a moderation tool for survey responses.
6. Testing Tools
Often I find myself building dashboards for each of the external APIs we integrate with.
This serves the dual function of allowing us to test the API as well as debug things in production when issues inevitably arise. If we find ourselves performing the same action on an API repeatedly in development, our team builds that functionality into the corresponding tool.
Keeping Things Secure
We take many security precautions to keep our user data secure:
- We use JWT tokens for authentication with our backend, so Retool can be treated as a standard client most of the time.
- All direct database access is performed on a pseudonymized replica database, and we don’t allow direct mutations like INSERT/UPDATE/DELETE through Retool.
- We audit all dashboards and permissions thoroughly.
Try it!
We’ve found low-code tools like Retool to be an accelerant to our business and believe you will too. Stay tuned for more blog posts about Zebra Engineering and our stack. 🚢
Want to build the world’s greatest creator community platform? We’re hiring!
Author: Alex Kern
