GETTING STARTED
---
# Introduction
Flashboard is an instant admin panel and CMS for your database. Connect your PostgreSQL database and get a complete admin panel and CMS in under 2 minutes. No code required, and your credentials stay encrypted with a key only you own.
### Is Flashboard for me?
- If you vibe-coded an app with Lovable, Replit, Bolt, or v0.
- If you're a founder whose startup outgrew manual database queries.
- If you're making your first customer support hire and don't want to share database access.
- If you're a contractor whose clients expect a CMS but won't pay to build one.
Then, yes. You need to manage your app's data and content — not to build an admin panel and CMS from scratch.
### Should my startup build or buy an admin panel?
Building a custom admin panel typically takes weeks of engineering time that could go toward user-facing features. For most startups, that trade-off doesn't make sense. Flashboard generates an admin panel from your existing database schema, so you can focus your engineering effort where it matters.
### How do I delegate customer support without giving database access?
Create team-based panels with granular permissions, down to the column level. Your support team gets exactly the access they need to help customers, without database credentials or the ability to accidentally break things.
### Can I use Flashboard for client projects?
Yes. Many freelancers and agencies do. Instead of building a custom admin panel for every client (or explaining why you can't), connect Flashboard to their database and hand them a working admin panel. It's included value you don't have to build or maintain.
### Do I need to build an admin panel for my app?
Not anymore. Flashboard generates one from your existing database schema in under 2 minutes. Your engineering time is better spent on user-facing features.
### How do I manage my database without writing SQL?
Connect Flashboard to your PostgreSQL database and get a complete interface for viewing, editing, and managing your data. Works with databases from Supabase, Neon, Lovable, Replit, Bolt, v0, and any PostgreSQL host.
### Can I give my team access without sharing database credentials?
Yes. Create team-based panels with granular permissions, down to the column level. Each team member gets their own login, and you control exactly what they can see and do.
### How is Flashboard different from Retool?
Retool is a low-code platform for building custom internal tools. Flashboard is an instant admin panel. No building required. Connect your database and you're done. If you need dashboards, charts, and custom workflows, Retool might be the better choice. If you need a straightforward admin panel for CRUD operations, team access, and content management, Flashboard gets you there in 2 minutes instead of 2 weeks.
### Does Flashboard work with my existing database?
Yes. Flashboard connects to any PostgreSQL database, whether it's hosted on Supabase, Neon, Railway, Render, DigitalOcean, AWS, or your own server. It reads your existing schema and generates the admin panel automatically. No migrations, no schema changes, no lock-in.
### Is my data safe?
Flashboard is built security-first. Your database credentials are encrypted end-to-end with keys only you control — even we can't access them. Combined with static IPs for allowlisting and optional two-factor authentication, your data stays yours. See our [security page](https://www.getflashboard.com/docs/getting-started/security) for the full details.
### Quickstart
[Sign up](https://www.getflashboard.com/auth) and create a panel using your connection URL. Check out our [integrations](https://www.getflashboard.com/integrations) if you need help finding it.
---
# Use cases
Flashboard is built for indie developers, startups, freelancers, and agencies who need to manage their database content without building admin panels from scratch or integrating with a complex CMS.
### You vibe-coded an app
You finished your app with Lovable, Cursor, Bolt, v0, or Replit. It works. Users are signing up. Now you need to manage your data, and you don't want to go through another few weeks of prompting just to build an admin panel or CMS.
Connect your database to Flashboard and get a complete admin panel and CMS in under 2 minutes. Edit customer data, write blog posts with a Notion-like editor, upload images to your storage, and manage everything from one place. All without writing another single prompt.
#### Do I need to build an admin panel or CMS for my vibe-coded app?
Not anymore. Flashboard generates both from your existing database schema. Manage your app's data and your content in the same place.
#### Can I use it as a CMS for my blog or landing pages?
Yes. Store your content in PostgreSQL and edit it with Flashboard's Notion-like rich text editor. Write HTML content, upload images, and publish directly to your database.
#### What if I don't know SQL?
You don't need to. Flashboard gives you a visual interface for everything: filtering, sorting, editing records, writing content, and uploading files. If you can use Notion, you can use Flashboard.
#### Will Flashboard work with my Lovable, Cursor, or Bolt database?
Yes. Flashboard connects to any PostgreSQL database. If your AI tool uses PostgreSQL or Supabase (most do), you can connect it. Check our [integrations page](https://www.getflashboard.com/integrations) for specific instructions.
---
### Your startup is outgrowing manual queries
You've been running SQL queries to manage customer data and update content. It worked when you were small, but now you're spending real engineering time on internal operations. Every support request or content update means a developer context-switching.
Flashboard generates an admin panel and CMS from your existing schema in under 2 minutes. Your team manages customer data. Your marketing team updates landing page copy. No development time, no maintenance burden.
#### Should my startup build or buy an admin panel?
Building a custom admin panel typically takes weeks of engineering time, even with modern admin frameworks. For most startups, that time is better spent on user-facing features. Flashboard gets you a working admin panel and CMS now, so you can decide later if you need something custom.
#### What if we already have custom admin pages?
Most teams end up needing custom admin interfaces for their core workflows. That makes sense. But you don't need custom code for everything. Use Flashboard for the rest: customer lookups, content editing, order management, and the dozens of smaller admin pages you'd otherwise have to build and maintain yourself.
#### Can my marketing team update content without engineering help?
Yes. Give your marketing team access to Flashboard, and they can update landing pages, blog posts, and product descriptions directly. Rich text editing, image uploads, everything they need. No more content update tickets or separate Squarespace/Webflow site for marketing pages.
#### When should we stop using manual database queries?
When queries start eating engineering time. If you're context-switching to run support queries or update content, it's time. Flashboard handles the interface so your engineers can focus on your product.
#### Is it worth the cost?
Flashboard's Team plan includes unlimited seats. Compare that to the engineering hours you'd spend building and maintaining a custom solution, or to per-seat pricing that scales with your team.
---
### You're delegating customer support
You're hiring your first support person, or maybe your third. They need access to customer data, but you can't give everyone database credentials. You need controlled access with clear boundaries.
Flashboard lets you create separate panels for different teams. Configure which tables are visible, which columns are shown, and whether editing is allowed. Your support team gets a panel for customer data. Your content team gets a panel for the blog. Everyone sees exactly what they need.
#### How do I give my support team database access safely?
Create a team in Flashboard and connect a panel to your database. Configure which tables and columns are visible, and whether records can be created, edited, or deleted. Invite your support members. Each person gets their own login, and you can enforce two-factor authentication (2FA) for the entire team.
#### Can different teams have different access?
Yes. Create separate teams, each with their own panel connected to your database. Your support team's panel shows customer data. Your content team's panel shows blog posts and landing pages. Same database, different views.
#### Can I restrict what data they can see?
Yes, down to the column level. Hide sensitive columns like passwords or internal notes. Show only what's needed for the job. Update the configuration anytime without touching your database.
#### Will non-technical team members be able to use it?
Absolutely. Flashboard is designed for team members who've never seen a SQL query. Filtering, searching, editing records, writing content with the rich text editor. It all works like a simple web app. Most teams are productive within minutes.
---
### You're a freelancer or agency
Your clients want to spend 100% of their budget on user-facing features. They say they'll figure out operations later. But you've launched enough projects to know better: they'll need to manage their data the moment the software goes live.
Flashboard lets you include a complete admin panel and CMS without eating into development hours. Connect it to your client's database during handoff. They get a professional interface they can actually use. You move on to the next project.
#### My clients don't want to pay for admin panels. What do I do?
Stop trying to convince them. Include Flashboard in your deliverables and skip the conversation entirely. Your clients get what they need, you don't spend hours building something they didn't budget for.
#### What about other admin panel tools?
Most are too complicated and still require development hours to set up and maintain. Flashboard connects to your client's database and generates a working panel in minutes. No custom code, no ongoing maintenance on your side.
#### Can my clients actually use it?
Yes. Flashboard is designed for non-technical users. Clients can edit blog posts with the rich text editor, upload images, update product descriptions, and manage their content. No training manual required.
#### Can I reuse Flashboard across client projects?
Yes. Each client gets their own panel connected to their database. You set up the connection, configure which tables and columns are visible, and hand it over. The process takes minutes, not days.
#### What if my client needs content changes later?
They make them directly. That's the point. For database schema changes, you update the structure and sync Flashboard in a few clicks. No CMS maintenance on your side.
---
### Get started
[Sign up for free](https://www.getflashboard.com/auth) and create your first panel. Check out our [integrations](https://www.getflashboard.com/integrations) if you need help finding your connection URL.
---
# Basic guide
Watch how to create a panel and customize your CRUD operations in under five minutes:
### Creating a panel
To create a panel, copy the connection URL from your database provider and paste it into Flashboard. Pick a namespace if your database uses one (if you're not sure, just use "public"). Choose a name for your panel, then confirm your password so we can [encrypt your credentials](https://www.getflashboard.com/docs/getting-started/security).
That's it. Your data appears instantly, organized into tabs for each table.
### Navigating your panel
Each tab represents a table from your database. You can reorder tabs by dragging them. When you open a tab, you'll see the default list view that Flashboard created for you. Pagination, search, and filters are already built in.
### Customizing the table view
Want to change what appears in your list? Go to Build → Table settings. From there you can:
- Reorder columns by dragging
- Remove fields you don't need
- Set the default sort order
### Viewing item details
Click the eye icon next to any row to see all its fields and associations. If your tables have [foreign keys](https://www.getflashboard.com/docs/data-display/foreign-key-labels), you can navigate directly to related records. Click a linked item and you'll jump straight to it.
### Customizing the detail view
Go to Build → Detail settings to control what shows up in the detail view. You can:
- Show or hide specific fields
- Reorder how fields appear
- Toggle associations on or off
### Creating new items
By default, you can create new items from any tab. To customize this, go to Build → New item settings. You can disable creation entirely, or choose exactly which fields appear in the form.
Need to duplicate an existing item? Click the duplicate icon and you'll get a pre-filled form with that item's data.
### Editing items
Most fields are editable by default. To change this, go to Build → Edit item settings. You can turn off editing completely, or limit it to specific fields. If you only want users to toggle a "highlighted" flag, for example, you can allow just that field.
### Deleting items
The delete icon appears by default on each row. If you want to prevent deletions, go to Build and toggle off "Allow deleting". The icon disappears and users can no longer delete anything from that tab.
### Managing tabs
Tab names are inferred from your database, but you can [rename them](https://www.getflashboard.com/docs/tabs/edit-tab) to whatever makes sense for your team. Click on a tab to edit it, change the name, or delete it entirely. You can also create new tabs from any table in your database.
---
# Security
Your login password encrypts your database's connection URL. Only you have access to your data.
When you create a panel, you'll need to reenter your login password. Flashboard uses it to encrypt your database connection URL and store it securely. You'll need to reenter your login password occasionally to decrypt it and keep using your panels.
We never save your connection string nor your data. Even if a malicious actor had access to Flashboard's servers, your database would still be safe.
### Static IPs
It's good practice to block unknown IPs from accessing your PostgreSQL instance. Flashboard has static IPs that you can add to your database's allowlist.
You can see the IPs on the "Connect to your PostgreSQL Database" page, when creating a new panel.
### Two-factor authentication
We recommend enabling two-factor authentication on your account and enforcing it for your whole team.
---
INTEGRATIONS
---
# Integrate PostgreSQL with Flashboard
### 1. Find your database credentials
Check the documentation of your PostgreSQL hosting service to find your *Database Credentials*. The credentials can appear in two formats: a *Connection URL*, also called a *Connection string*, or a list containing username, password, host, database and port.
If you find a connection string, copy it. That's all you need.
If you find the list of credentials, you'll need to format them as a connection URL. They contain a `"user"`, `"password"`, `"host"`,`"database"` and `"port"`. If `"port"` isn't mentioned, the default port is `5432`, so try that one.
Create your connection URL from the credentials using the following template. Substitute each part between `"<>"` for your credential values.
```javascript
postgres://:@:5432/
```
For example, if your credentials are:
```javascript
user: bob
password: 123456
host: db.example.com
database: awesomedb
```
Your connection URL will be:
```javascript
postgres://bob:123456@db.example.com:5432/awesomedb
```
Copy it to use in the next step.
For a complete tutorial on PostgreSQL connection strings, read [this great article](https://www.prisma.io/docs/orm/more/help-and-troubleshooting/dataguide/connection-uris) by our friends at Prisma.
### 2. Create a Flashboard account
Once you have copied your connection URL, [sign in](https://www.getflashboard.com/auth) to Flashboard. Enter your email and choose a strong password. The password will be used to encrypt your database credentials, so make sure you remember it!
Complete your profile:
### 3. Connect a database
Choose *Connect my real database*
Paste the Connection String you copied from step 1 on the field *Connection URL*.
Choose a panel name and slug, then confirm the same password you used to sign up. It will be used to encrypt the connection URL. Only you and your team will have access to your data.
You're connected and ready to go!
### 4. Optional: customize your tabs
We generated a panel for you, and enabled all actions on your tabs by default. But you can always customize the fields or disable specific actions, like creating, updating, or deleting items.
Congratulations, you have a live CMS and admin panel for your PostgreSQL database! 🎉
From here on, you can use it as-is, create more tabs, or share panels with team members.
---
# Integrate Supabase with Flashboard
### 1. Find your Supabase project connection string
Open your Supabase project. Click *Connect* to see the connection options.
You'll see the "Connect to your project" page. Go down to the "Session pooler" section and click the copy icon to copy your connection URL.
You'll need to replace `[YOUR-PASSWORD]` on the Connection String with your real Database Password. That is the one you used to create your Supabase project.
If you don't have a project yet, create one with a database that has at least a table with a few columns.
### 2. Create a Flashboard account
Once you have copied your connection URL, [sign in](https://www.getflashboard.com/auth) to Flashboard. Enter your email and choose a strong password. The password will be used to encrypt your database credentials, so make sure you remember it!
Complete your profile:
### 3. Connect a database
Choose *Connect my real database*
Paste the Connection String you copied from step 1 on the field *Connection URL*.
Choose a panel name and slug, then confirm the same password you used to sign up. It will be used to encrypt the connection URL. Only you and your team will have access to your data.
You're connected and ready to go!
### 4. Optional: customize your tabs
We generated a panel for you, and enabled all actions on your tabs by default. But you can always customize the fields or disable specific actions, like creating, updating, or deleting items.
Congratulations, you have a live CMS and admin panel for your Supabase database! 🎉
From here on, you can use it as-is, create more tabs, or share panels with team members.
---
# Integrate Neon with Flashboard
### 1. Find your Neon database connection string
If you don't have a project, create one with a database and a table with a few columns.
Open your Neon project dashboard and click on "Connect".
You'll see your connection options, you can leave the default settings. Click on "Copy snippet" to copy your connection string.
### 2. Create a Flashboard account
Once you have copied your connection URL, [sign in](https://www.getflashboard.com/auth) to Flashboard. Enter your email and choose a strong password. The password will be used to encrypt your database credentials, so make sure you remember it!
Complete your profile:
### 3. Connect a database
Choose *Connect my real database*
Paste the Connection String you copied from step 1 on the field *Connection URL*.
Choose a panel name and slug, then confirm the same password you used to sign up. It will be used to encrypt the connection URL. Only you and your team will have access to your data.
You're connected and ready to go!
### 4. Optional: customize your tabs
We generated a panel for you, and enabled all actions on your tabs by default. But you can always customize the fields or disable specific actions, like creating, updating, or deleting items.
Congratulations, you have a live CMS and admin panel for your Neon database! 🎉
From here on, you can use it as-is, create more tabs, or share panels with team members.
---
# Integrate Lovable with Flashboard
### 1. Find your Lovable app's database URL
Go to your Lovable app and look for the Supabase button on the top toolbar. If you don't have a database, ask the agent to add one. Check [Lovable's Supabase integration docs](https://docs.lovable.dev/integrations/supabase) for more details.
Click the Supabase button to open its menu, then click the "Dashboard" option.
Your Supabase project will open on another tab. Click *Connect* to see the connection options.
You'll see the "Connect to your project" page. Scroll down to the "Transaction pooler" section and click the copy icon to copy your connection URL.
You'll need to replace `[YOUR-PASSWORD]` on the Connection String with your real Database Password. That is the one you used to create your Supabase project.
**Attention!** Treat your `DATABASE_URL` like a password. Do not share it.
### 2. Create a Flashboard account
Once you have copied your connection URL, [sign in](https://www.getflashboard.com/auth) to Flashboard. Enter your email and choose a strong password. The password will be used to encrypt your database credentials, so make sure you remember it!
Complete your profile:
### 3. Connect a database
Choose *Connect my real database*
Paste the Connection String you copied from step 1 on the field *Connection URL*.
Choose a panel name and slug, then confirm the same password you used to sign up. It will be used to encrypt the connection URL. Only you and your team will have access to your data.
You're connected and ready to go!
### 4. Optional: customize your tabs
We generated a panel for you, and enabled all actions on your tabs by default. But you can always customize the fields or disable specific actions, like creating, updating, or deleting items.
Congratulations, you have a live CMS and admin panel for your Lovable database! 🎉
From here on, you can use it as-is, create more tabs, or share panels with team members.
---
# Integrate Replit with Flashboard
### 1. Find your Replit app's database URL
Go to your Replit app and look for the blue elephant icon on your left toolbar. If you don't have a database yet, ask the agent to add one for you.
Click the database icon to open the Database tab on the right side of your window. Click the "Commands" tab.
Scroll down to "Environment Variables" to find your `DATABASE_URL`. It'll be a hidden text starting with`"postgresql://..."`. You'll need it soon, click the Copy icon.
**Attention!** Treat your `DATABASE_URL` like a password. Do not share it.
### 2. Create a Flashboard account
Once you have copied your connection URL, [sign in](https://www.getflashboard.com/auth) to Flashboard. Enter your email and choose a strong password. The password will be used to encrypt your database credentials, so make sure you remember it!
Complete your profile:
### 3. Connect a database
Choose *Connect my real database*
Paste the Connection String you copied from step 1 on the field *Connection URL*.
Choose a panel name and slug, then confirm the same password you used to sign up. It will be used to encrypt the connection URL. Only you and your team will have access to your data.
You're connected and ready to go!
### 4. Optional: customize your tabs
We generated a panel for you, and enabled all actions on your tabs by default. But you can always customize the fields or disable specific actions, like creating, updating, or deleting items.
Congratulations, you have a live CMS and admin panel for your Replit database! 🎉
From here on, you can use it as-is, create more tabs, or share panels with team members.
---
# Integrate v0 with Flashboard
### 1. Find your v0 app's database URL
v0 has multiple database options. Click on Integrations to open the side menu.
Go to either your Supabase or Neon integration and click `Manage`.
#### If you have Supabase:
You can copy your connection string directly from the integration page. Under "Quickstart", make sure you're on the first tab, `.env.local`. Click `Show secret`.
Find the first line, `POSTGRES_URL`. Copy its value.
Make sure you copy it without the quotes. You might need to remove the `sslmode=require` at the end of the connection string.
Once you've copied it, go to step 2.
#### If you have Neon:
You can copy your connection string directly from the integration page. Under "Quickstart", make sure you're on the first tab, `.env.local`. Click `Show secret`.
Copy the value of `DATABASE_URL`.
Once you've copied it, go to step 2.
### 2. Create a Flashboard account
Once you have copied your connection URL, [sign in](https://www.getflashboard.com/auth) to Flashboard. Enter your email and choose a strong password. The password will be used to encrypt your database credentials, so make sure you remember it!
Complete your profile:
### 3. Connect a database
Choose *Connect my real database*
Paste the Connection String you copied from step 1 on the field *Connection URL*.
Choose a panel name and slug, then confirm the same password you used to sign up. It will be used to encrypt the connection URL. Only you and your team will have access to your data.
You're connected and ready to go!
### 4. Optional: customize your tabs
We generated a panel for you, and enabled all actions on your tabs by default. But you can always customize the fields or disable specific actions, like creating, updating, or deleting items.
Congratulations, you have a live CMS and admin panel for your v0 database! 🎉
From here on, you can use it as-is, create more tabs, or share panels with team members.
---
# Integrate Bolt with Flashboard
### 1. Find your Bolt app's database URL
Go to your Bolt app and look for the Supabase button on the top toolbar. If you don't have a database yet, ask the agent to add one for you. You can check [Bolt's database docs](https://support.bolt.new/docs/database#database) for more details.
Click the Supabase button to open its menu, then click "Go to Supabase".
Your Supabase project will open on another tab. Click *Connect* to see the connection options.
You'll see the "Connect to your project" page. Go down to the "Transaction pooler" section and click the copy icon to copy your connection URL.
You'll need to replace `[YOUR-PASSWORD]` on the Connection String with your real Database Password. That is the one you used to create your Supabase project.
**Attention!** Treat your `DATABASE_URL` like a password. Do not share it.
### 2. Create a Flashboard account
Once you have copied your connection URL, [sign in](https://www.getflashboard.com/auth) to Flashboard. Enter your email and choose a strong password. The password will be used to encrypt your database credentials, so make sure you remember it!
Complete your profile:
### 3. Connect a database
Choose *Connect my real database*
Paste the Connection String you copied from step 1 on the field *Connection URL*.
Choose a panel name and slug, then confirm the same password you used to sign up. It will be used to encrypt the connection URL. Only you and your team will have access to your data.
You're connected and ready to go!
### 4. Optional: customize your tabs
We generated a panel for you, and enabled all actions on your tabs by default. But you can always customize the fields or disable specific actions, like creating, updating, or deleting items.
Congratulations, you have a live CMS and admin panel for your Bolt database! 🎉
From here on, you can use it as-is, create more tabs, or share panels with team members.
---
# Integrate Create with Flashboard
### 1. Find your Create project's database URL
Go to your Create project. If you don't have a database yet, ask the agent to add one for you. Open the top menu.
Select "Secrets"
On the Secrets page, look for the one called `DATABASE_URL`.
Important: Create generates a test database when you add one to your project, and another production database only when you **publish** it. Make sure you've published your project before connecting it to Flashboard, since Create only shows the production `DATABASE_URL`.
Click the eye icon to reveal its value.
**Attention!** Treat your `DATABASE_URL` like a password. **Do not share it**.
Click the value to copy it to your clipboard.
### 2. Create a Flashboard account
Once you have copied your connection URL, [sign in](https://www.getflashboard.com/auth) to Flashboard. Enter your email and choose a strong password. The password will be used to encrypt your database credentials, so make sure you remember it!
Complete your profile:
### 3. Connect a database
Choose *Connect my real database*
Paste the Connection String you copied from step 1 on the field *Connection URL*.
Choose a panel name and slug, then confirm the same password you used to sign up. It will be used to encrypt the connection URL. Only you and your team will have access to your data.
You're connected and ready to go!
### 4. Optional: customize your tabs
We generated a panel for you, and enabled all actions on your tabs by default. But you can always customize the fields or disable specific actions, like creating, updating, or deleting items.
Congratulations, you have a live CMS and admin panel for your Create database! 🎉
From here on, you can use it as-is, create more tabs, or share panels with team members.
---
# Integrate Xano with Flashboard
### 1. Find your Xano database credentials
To connect Flashboard to your Xano database, you'll need the [Database Connector premium add-on](https://docs.xano.com/xano-features/infrastructure/direct-database-connector).
If you already have it, follow their documentation to find your *Database Credentials*. The credentials contain a `user`,`pass`, `host` and `database`. The Xano docs don't mention a `port`, but the example they provide uses the default port `5432`, so it's safe to assume that's what you should use.
Create your connection URL from the credentials using the following template. Substitute each part between `<>` for your credential values.
```javascript
postgres://:@:5432/
```
For example, if your credentials are:
```javascript
user: bob
password: 123456
host: db.example.com
database: awesomedb
```
Your connection URL will be:
```javascript
postgres://bob:123456@db.example.com:5432/awesomedb
```
Copy it to use in the next step.
### 2. Create a Flashboard account
Once you have copied your connection URL, [sign in](https://www.getflashboard.com/auth) to Flashboard. Enter your email and choose a strong password. The password will be used to encrypt your database credentials, so make sure you remember it!
Complete your profile:
### 3. Connect a database
Choose *Connect my real database*
Paste the Connection String you copied from step 1 on the field *Connection URL*.
Choose a panel name and slug, then confirm the same password you used to sign up. It will be used to encrypt the connection URL. Only you and your team will have access to your data.
You're connected and ready to go!
### 4. Optional: customize your tabs
We generated a panel for you, and enabled all actions on your tabs by default. But you can always customize the fields or disable specific actions, like creating, updating, or deleting items.
Congratulations, you have a live CMS and admin panel for your Xano database! 🎉
From here on, you can use it as-is, create more tabs, or share panels with team members.
---
LOCAL DATABASES
---
# Introduction
Flashboard offers free access to local databases with unlimited edits. [Connect your local PostgreSQL server](https://www.getflashboard.com/docs/local-databases/connect-your-local-database) to manage development and test databases directly from your browser, without deploying them to a remote server first.
## How it works
Run `npx flashboard@latest local` in your terminal to create a secure tunnel between your local PostgreSQL and Flashboard's servers. Your database stays on your machine, but you can manage it through the same interface you use for production databases.
The tunnel remains active as long as the command is running. Close the terminal, and the connection closes with it.
## Security
Local database connections use multiple layers of security:
1. **Encrypted credentials**: Your database credentials are encrypted with a key only you own. Even Flashboard's team cannot access them.
2. **Encrypted tunnel**: All traffic between your machine and Flashboard travels through an encrypted tunnel.
3. **Flashboard CLI authentication**: The tunnel only accepts connections from your authenticated CLI session, preventing unauthorized access to your local database.
4. **SSL required (self-signed allowed)**: The PostgreSQL connection through the tunnel [requires SSL](https://www.getflashboard.com/docs/local-databases/enabling-ssl). This ensures your data is encrypted end-to-end. We accept self-signed certificates since CA-signed certificates aren't practical for localhost. This means the SSL layer doesn't verify server identity, which removes protection against man-in-the-middle attacks at that layer. We believe the other security layers offer enough protection, but please consider this security trade-off before using local databases with Flashboard.
---
# Connect your local database
Connect your local PostgreSQL database to Flashboard in a few steps. You'll be managing your data in minutes.
## Prerequisites
Before you start, make sure you have:
- **Node.js** installed on your machine
- **PostgreSQL** running locally with SSL enabled
If your PostgreSQL server doesn't have SSL enabled, follow our guide first: [Enabling SSL on your local database](https://www.getflashboard.com/docs/local-databases/enabling-ssl).
## Step 1: Start the Flashboard CLI
Open your terminal and run:
```bash
npx flashboard@latest local
```
The first time you run this command, it will ask you to sign in to your Flashboard account. After signing in, the CLI creates a secure tunnel to your machine and keeps it open.
You'll see a message confirming the connection is active. Keep this terminal window open while you work with your local database.
## Step 2: Create a panel with your local connection
Go to Flashboard and create a new panel. When asked for the connection string, use your local PostgreSQL URL:
```
postgres://username:password@localhost:5432/your_database
```
Read our [PostgreSQL integration docs](https://www.getflashboard.com/docs/integrations/postgresql) for instructions on how to build your connection URL.
Flashboard recognizes `localhost` and `127.0.0.1` as local connections and routes them through the secure tunnel.
## Step 3: Verify the connection
Once connected, you'll see your database tables in Flashboard. A green indicator in the header shows that the local connection is active.
If you close the CLI, the connection indicator turns gray and queries to your local database will fail. Just run `npx flashboard@latest local` again to reconnect.
## Troubleshooting
### "SSL connection failed" error
Your PostgreSQL server needs SSL enabled for local connections. Follow our guide: [Enabling SSL on your local database](https://www.getflashboard.com/docs/local-databases/enabling-ssl).
### "Local Flashboard connection is not active" error
The Flashboard CLI isn't running. Open a terminal and run:
```bash
npx flashboard@latest local
```
### Connection times out
Make sure PostgreSQL is running and accepting connections on the port specified in your connection string (default is 5432). You can test this with:
```bash
psql "postgres://username:password@localhost:5432/your_database?sslmode=require"
```
### Wrong credentials
Double-check your PostgreSQL username and password. If you're using the default PostgreSQL installation, the username is often `postgres`.
---
# Enabling SSL on your local database
Flashboard requires SSL for local database connections. This ensures your data is encrypted end-to-end, even when traveling through the secure tunnel.
If you see an "SSL connection failed" error, follow this guide to enable SSL on your PostgreSQL server.
> 💡 **Pro tip**: paste this article into [Claude Code](https://claude.com/product/claude-code) and let it run the commands for you. Carefully review each command before running.
## Check if SSL is already enabled
Before making changes, check if SSL is already enabled on your PostgreSQL server:
```bash
psql -c "SHOW ssl;"
```
If this returns `on`, SSL is already enabled. Skip to the [Verify SSL is working](#verify-ssl-is-working) section to confirm it's working correctly.
If it returns `off` or you get an error, continue with the steps below.
## Find your PostgreSQL directories
Run these commands to find your PostgreSQL directories:
```bash
# Configuration file location
psql -c "SHOW config_file;"
# Data directory (where certificates go)
psql -c "SHOW data_directory;"
```
Save both paths — you'll need them throughout this guide.
> **Note:** On some systems (like Ubuntu/Debian), the configuration files and data directory are in different locations. The data directory is where your SSL certificates must go.
## Back up your PostgreSQL configuration
Back up your configuration files before making changes. The `pg_hba.conf` file is in the same directory as `postgresql.conf`:
```bash
# Navigate to the directory from SHOW config_file
cp postgresql.conf postgresql.conf.backup
cp pg_hba.conf pg_hba.conf.backup
```
Use `sudo` if needed (common on Linux).
## Generate SSL certificates
PostgreSQL needs a certificate and private key to enable SSL. You can generate a self-signed certificate for local development.
> **Note:** If you already have `server.key` and `server.crt` files in your data directory, SSL may already be configured. Skip to "Configure postgresql.conf" to verify, or back up your existing certificates before regenerating.
### macOS / Linux
Run these commands in your PostgreSQL data directory (use the path from `SHOW data_directory`):
```bash
# Navigate to your data directory
cd /path/to/your/data/directory
# Generate a private key
openssl genrsa -out server.key 2048
# Set proper permissions (required by PostgreSQL)
chmod 600 server.key
# Generate a self-signed certificate (valid for 365 days)
openssl req -new -x509 -days 365 -key server.key -out server.crt -subj "/CN=localhost"
```
**If PostgreSQL runs as a different user** (common on Linux servers), change ownership:
```bash
sudo chown postgres:postgres server.key server.crt
```
On macOS with Homebrew or Postgres.app, PostgreSQL runs as your user, so no ownership change is needed.
**SELinux (RHEL/Fedora/CentOS):** If SELinux is enabled, restore the security context:
```bash
sudo restorecon -v server.key server.crt
```
### Windows
Windows requires OpenSSL and has different file permission handling.
**Step 1: Install OpenSSL**
The easiest option is to install [Git for Windows](https://git-scm.com/install/windows), which includes OpenSSL. Alternatively, install OpenSSL for Windows from [slproweb.com/products/Win32OpenSSL.html](https://slproweb.com/products/Win32OpenSSL.html).
**Step 2: Generate certificates**
Open **Git Bash** and navigate to your PostgreSQL data directory (use the path from `SHOW data_directory`):
```bash
# Navigate to your data directory
cd "/path/to/your/data/directory"
# Generate a private key
openssl genrsa -out server.key 2048
# Generate a self-signed certificate (valid for 365 days)
openssl req -new -x509 -days 365 -key server.key -out server.crt -subj "/CN=localhost"
```
**Step 3: Set file permissions**
PostgreSQL on Windows checks Windows ACLs and will refuse to start if the key file permissions are too open. Set proper permissions using one of these methods:
**Option A: PowerShell (run as Administrator)**
```bash
cd "C:\path\to\your\data\directory"
icacls server.key /inheritance:r
icacls server.key /grant:r "$($env:USERNAME):(F)"
```
**Option B: File Explorer**
1. Right-click `server.key` → Properties → Security tab → Advanced
2. Click "Disable inheritance" → "Remove all inherited permissions"
3. Click "Add" → "Select a principal" → Enter your Windows username → OK
4. Check "Full control" → OK → Apply
If PostgreSQL runs as a service under a different account (like `NT AUTHORITY\NetworkService`), grant that account access instead of your username.
## Configure postgresql.conf
Open your `postgresql.conf` file and update these settings:
```
ssl = on
ssl_cert_file = 'server.crt'
ssl_key_file = 'server.key'
```
Save the file.
## Configure pg_hba.conf
The `pg_hba.conf` file controls client authentication. You need to allow SSL connections from localhost.
Find the file in the same directory as `postgresql.conf` (use `SHOW config_file` to find it).
**Important:** Rules are processed top-to-bottom, and the first match wins. Add these lines near the **top** of the file, before any existing `host` rules for localhost:
```
# Allow SSL connections from localhost
hostssl all all 127.0.0.1/32 scram-sha-256
hostssl all all ::1/128 scram-sha-256
```
Match the authentication method to your existing configuration:
- `scram-sha-256` — Modern default (PostgreSQL 14+)
- `md5` — Legacy password hashing (older installations)
- `trust` — Passwordless connections (common for local development)
The key is using `hostssl` (which requires SSL) instead of `host` (which allows both SSL and non-SSL connections).
If you have existing `host all all 127.0.0.1/32` lines, either comment them out or ensure your new `hostssl` lines appear before them.
> **Tip:** If SSL connections fail after restarting, the most common cause is pg_hba.conf rule ordering. Run `grep -n "host" pg_hba.conf` to see all rules and their line numbers.
## Restart PostgreSQL
After making these changes, restart PostgreSQL for them to take effect.
### macOS (Homebrew)
```bash
# PostgreSQL 17 (adjust version number as needed)
brew services restart postgresql@17
```
### macOS (Postgres.app)
In Postgres.app, click the server name, then click "Stop". Once stopped, click "Start" to restart with the new configuration.
Alternatively, use `pg_ctl` from the terminal:
```bash
# PostgreSQL 17 (adjust version number as needed)
/Applications/Postgres.app/Contents/Versions/latest/bin/pg_ctl restart -D ~/Library/Application\ Support/Postgres/var-17
```
### Ubuntu/Debian
```bash
sudo systemctl restart postgresql
```
### Windows
Restart the PostgreSQL service from the Services application, or run:
```bash
# PostgreSQL 17 (adjust version number as needed)
Restart-Service postgresql-x64-17
```
### RHEL/Fedora/CentOS
```bash
# PostgreSQL 17 (adjust version number as needed)
sudo systemctl restart postgresql-17
```
### Arch Linux
```bash
sudo systemctl restart postgresql
```
## Verify SSL is working
Test that SSL is enabled by connecting with `psql`:
```bash
psql "postgres://username:password@localhost:5432/your_database?sslmode=require"
```
Read our [PostgreSQL integration docs](https://www.getflashboard.com/docs/integrations/postgresql) for help building your connection URL.
**Windows (CMD or PowerShell):** Use double quotes for the connection string. If you have issues, try escaping special characters or use Git Bash instead.
If the connection succeeds, SSL is working. You can also verify by running this query:
```sql
SHOW ssl;
```
It should return `on`. You're now ready to [connect your local database](https://www.getflashboard.com/docs/local-databases/connect-your-local-database) to Flashboard.
## Certificate renewal
The self-signed certificate expires after 365 days. When it expires, PostgreSQL will still start, but SSL connections may fail with certificate errors.
To renew, regenerate the certificate using the same commands from the "Generate SSL certificates" section above. You'll need to restart PostgreSQL after replacing the certificate.
## Special environments
### Docker
If you're running PostgreSQL in a Docker container, SSL configuration depends on your Docker image. Many official images have SSL disabled by default.
For the official `postgres` image, you'll need to mount SSL certificates and modify the PostgreSQL configuration. See the [official postgres Docker image documentation](https://hub.docker.com/_/postgres) for details.
### Windows Subsystem for Linux (WSL)
If you're running PostgreSQL inside WSL, follow the Ubuntu/Debian instructions above. Your data directory is typically `/var/lib/postgresql/VERSION/main/`.
Make sure you're connecting to the PostgreSQL instance running inside WSL, not a separate Windows installation.
## Troubleshooting
### PostgreSQL won't start after changes
Check the PostgreSQL logs for errors:
**macOS (Homebrew):**
```bash
# PostgreSQL 17 (adjust version number as needed)
# Check service status
brew services info postgresql@17
# View logs
cat /opt/homebrew/var/log/postgresql@17.log # Apple Silicon
cat /usr/local/var/log/postgresql@17.log # Intel
```
**macOS (Postgres.app):**
Open Postgres.app, click the server name, then click "Server Logs" in the sidebar.
**Ubuntu/Debian:**
```bash
sudo journalctl -u postgresql --no-pager -n 50
# or (adjust version number as needed)
sudo tail -50 /var/log/postgresql/postgresql-17-main.log
```
**Windows:**
Check the Windows Event Viewer under "Windows Logs" → "Application", or look for logs in your PostgreSQL data directory.
**RHEL/Fedora/CentOS:**
```bash
# PostgreSQL 17 (adjust version number as needed)
sudo journalctl -u postgresql-17 --no-pager -n 50
# or
sudo tail -50 /var/lib/pgsql/17/data/log/postgresql-*.log
```
**Arch Linux:**
```bash
sudo journalctl -u postgresql --no-pager -n 50
# or
sudo tail -50 /var/lib/postgres/data/log/postgresql-*.log
```
### Common errors
- **"could not load private key file"**: Check file permissions. On macOS/Linux, run `chmod 600 server.key` and ensure ownership matches the PostgreSQL process user. On Windows, check that only your user (or the PostgreSQL service account) has access—see the Windows permissions section above.
- **"SSL certificate file not found"**: Verify the certificate files are in your PostgreSQL data directory and the paths in `postgresql.conf` are correct.
- **Syntax error in config file**: Double-check your edits to `postgresql.conf` and `pg_hba.conf`. Restore from backup if needed.
---
DATA DISPLAY
---
# Foreign key labels
When you have a foreign key in your table, Flashboard will automatically select a human-readable label to display instead of a raw ID. This makes your data easier to understand and work with.
There is a set of rules to infer the best label from the related table.
## Label selection
Flashboard looks for a column in the related table that can serve as a good label. It prioritizes columns in the following order:
1. **Title or name**: It first looks for columns named `name`, `title`, or `full_name` that are not nullable (i.e., must have a value).
2. **Email**: If no title or name is found, it searches for an `email`, `email_address`, `e_mail`, or `e_mail_address` column that is not nullable.
3. **Identifiers**: If neither of the above is available, it looks for these common identifier columns: `sku`, `product_sku`, `model_number`, `code`, `identifier`, `catalog_number`, `barcode`, `bar_code`, or `isbn` that are not nullable.
If a column matching one of these criteria is found, Flashboard will use it as the label.
## Fallback labels
If no single, non-nullable column can be identified using the rules above, Flashboard will create a fallback label. It takes the first available value from the following columns, in order of priority:
1. A title or name column.
2. An email column.
3. An identifier column.
4. The table's primary key.
5. The first column that is non-nullable.
6. The first column in the table.
---
EDITING CONTENT
---
# Introduction
Aside from a CMS, Flashboard is also a complete admin panel for your database. That means you'll manage your data in the same place as your content.
You can edit any field by clicking it and making the changes you need, as long as the field is configured to be editable:
Some fields have an `Expand` icon:
Whenever you expand a field, you'll open a screen to edit it as `Plain text`, `Code`, `HTML,` or `Upload`. We'll explain each of these in future sections. In the meantime, remember to click the expand button whenever you need to focus on one field's content.
---
# Writing HTML
Flashboard includes a Notion-like HTML editor.
[Expand](https://www.getflashboard.com/docs/editing-content/introduction) any text field, and see the tabs below. Click the `HTML` tab and start writing:
In a new line, type `/` to open a menu with content options. Type to search for the command you're looking for:
You can also do pretty much anything you're used to doing on a rich text editor, for example:
- Select text to format it
- Paste a URL with text selected to turn it into a link
- [Upload images](https://www.getflashboard.com/docs/uploads/upload-images-inside-html)
- Paste content from other sources and preserve formatting
The HTML content will be stored in your database field with no styles, only markup. You can check the markup by alternating between the [Code](https://www.getflashboard.com/docs/editing-content/writing-code) and HTML tabs.
---
# Writing plain text
If you have a long, plain text field (no formatting needed), you can [expand it](https://www.getflashboard.com/docs/editing-content/introduction) to write with more focus and space. Click the `Plain text` tab and start writing:
---
# Writing code
Whenever you have code inside a field, you can use the code editor for syntax highlighting and a better coding experience. This is great for editing JSON fields, checking the markup for your [HTML fields](https://www.getflashboard.com/docs/editing-content/writing-html), etc.
[Expand](https://www.getflashboard.com/docs/editing-content/introduction) any text or JSON field, and see the tabs below. Click the `Code` tab and start writing:
The editor will try to detect your code's language automatically, but you can always change it on the languages menu:
---
# Rendering HTML content
Unlike other headless CMSs, Flashboard does not provide a REST or GraphQL API. You're responsible for loading the data directly using SQL or a backend like Supabase.
Once you have loaded the HTML content in your app, you can render it just like any other HTML. For example, in React you'd do something like the following:
```html
```
In Ruby on Rails, you'd do it like:
```erb
<%= my_html_content %>
```
And so on.
---
# Menus, pages, categories, etc
Traditional headless CMSs offer abstractions like menus, pages, categories, tags, and more. With Flashboard, you can forget all that and express everything with your business logic. Just like you're used to doing while developing your backend.
For example, if you're making a healthcare website and need a `Hospitals` menu, you can have a `hospitals` table instead of creating a "menu".
Then, when the user clicks on a hospital, your app can load the record from the `hospitals` table and show its information instead of using a "page" abstraction.
The same goes for tags, categories, and everything else. Design your database according to your business logic, and Flashboard will work with what you have.
---
# Drafts and publishing workflows
Drafts and other publishing workflows are essential for a great CMS experience. Instead of force-feeding you a complex workflow builder, Flashboard relies on your database design for drafts and content workflows.
We recommend using PostgreSQL Enum types for status fields. You can design them to be a perfect fit for your business logic, but for example, you can have an enum type with `draft` and `published` options and use it in your content table. Then, Flashboard will show you a dropdown menu:
### (Optional) Validations and rules
If you want to ensure your content is only published when it is valid, we recommend using PostgreSQL Triggers. Your triggers can validate your data and show a custom error message for each situation. For example, here's a trigger that checks if all necessary fields are not null before publishing:
```sql
CREATE OR REPLACE FUNCTION ensure_published_blog_post_has_required_fields()
RETURNS TRIGGER AS $$
BEGIN
IF NEW.state = 'published' AND (
NEW.title IS NULL OR
NEW.description IS NULL OR
NEW.content IS NULL
) THEN
RAISE EXCEPTION 'Please fill all fields before publishing.';
END IF;
RETURN NEW;
END;
$$ LANGUAGE plpgsql;
CREATE TRIGGER ensure_published_blog_post_has_required_fields_trigger
BEFORE INSERT OR UPDATE ON blog_posts
FOR EACH ROW
EXECUTE FUNCTION ensure_published_blog_post_has_required_fields();
```
Then, users will see the message on Flashboard when the trigger goes off:
---
UPLOADS
---
# Introduction
Flashboard lets you [connect your storage service](https://www.getflashboard.com/docs/uploads/connect-your-storage) and upload images and files to your CMS.
There are two types of uploads:
### 1. Images inside HTML content
When writing HTML, you can [upload images as part of the content](https://www.getflashboard.com/docs/uploads/upload-images-inside-html). When you do that, an `img` tag is stored inside your HTML content, with the `src` pointing to that image's *public URL* inside your storage.
### 2. Uploads to fields in your database
You can [upload images and files on any text or JSON field](https://www.getflashboard.com/docs/uploads/upload-images-and-files-on-fields) in your database. Flashboard stores references to multiple file uploads inside these columns in JSON format and includes everything you need to generate *secure URLs* for the files and [render them](https://www.getflashboard.com/docs/uploads/rendering-images-and-files).
We'll show you how to upload files and generate URLs soon, but let's [connect your storage service](https://www.getflashboard.com/docs/uploads/connect-your-storage) first.
---
# Connect your storage
Flashboard connects with any S3-compatible storage service, like [Supabase Storage](https://supabase.com/docs/guides/storage/uploads/s3-uploads), [AWS S3](https://aws.amazon.com/s3/), [DigitalOcean Spaces](https://www.digitalocean.com/products/spaces), and many more. To enable uploads, [expand any text or JSON field](https://www.getflashboard.com/docs/editing-content/introduction) and select the `Upload` tab:
Click `Connect storage service` and fill in the following:
Check your storage service's docs for instructions on where to find this information. If you're already using [@aws-sdk/client-s3](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-s3/), use the same parameters you're using to instantiate your client.
Click `Next`. If you have a connection error, tweak the parameters until you successfully connect. [Let us know](mailto:felipe@seasoned.cc?subject=Flashboard%20help) if you need help, and we'll guide you through this process.
### Choose your buckets
Flashboard stores your uploads in two separate buckets:
- **Bucket for secure uploads:** select a bucket that's protected from public access. This bucket will be used for uploads stored inside your database fields, and you'll need to generate a signed URL to access them.
- **Bucket for public uploads:** select a bucket that allows public access to all files. We'll only use it for image uploads inside HTML content.
Confirm your password, click `Connect storage`, and that's it! You're ready for file uploads.
---
# Upload images inside HTML
After [connecting your storage](https://www.getflashboard.com/docs/uploads/connect-your-storage), type `/image` on a new line inside the [HTML editor](https://www.getflashboard.com/docs/editing-content/writing-html) and press Enter:
Then, drag and drop your image or browse files to find it:
Click on `Upload 1 file`, and you're good to go:
**Pro tip:** you can also drag an image directly into your text to start uploading it 😉
When you upload images inside HTML content, we use your [public bucket](https://www.getflashboard.com/docs/uploads/connect-your-storage) and add an `img` tag with the `src` pointing to it. If you don't see your image after uploading the file, you might have to configure your bucket to allow public access. [**Let us know**](mailto:felipe@seasoned.cc?subject=Flashboard%20help) if you need help, and we'll guide you through this process.
---
# Upload images and files on fields
After [connecting your storage](https://www.getflashboard.com/docs/uploads/connect-your-storage), choose a text or JSON field and [expand it](https://www.getflashboard.com/docs/editing-content/introduction). Then, select the upload tab:
Add as many files as you want of any format:
Click on `Upload X files` and wait for the upload to complete. After it's done, you can review your files, add more, or remove ones you don't need before saving.
Finally, click `Save` and you're good to go.
---
# Editing images
You can edit your images before uploading. Drop the ones you want to upload, then click the pencil icon on its preview:
Then you can rotate, crop, zoom in/out, or flip your image horizontally:
Make your edits, click `Save`, and continue the upload process normally.
---
# Rendering images and files
Unlike other headless CMSs, Flashboard does not provide a REST or GraphQL API. You're responsible for loading the data directly using SQL or a backend like [Supabase](https://supabase.com/).
### Images inside HTML
Images [uploaded inside HTML](https://www.getflashboard.com/docs/uploads/upload-images-inside-html) content will be rendered together with your HTML. Follow our guide on [rendering HTML content](https://www.getflashboard.com/docs/editing-content/rendering-html-content) and that's it.
### Images and files uploaded on fields
When you [upload images and files on fields](https://www.getflashboard.com/docs/uploads/upload-images-and-files-on-fields), they are stored in your database column using a JSON format that includes everything you need to generate *secure URLs* for the files and render them. Here's an example:
```json
[
{
"flashboardStorage": "v1",
"serviceName": "s3",
"bucketName": "my-secure-bucket",
"key": "001b8672-76cf-4f6e-9950-798ca09b68bc",
"filename": "my-document.pdf",
"contentType": "application/pdf",
"size": 500316
},
{
"flashboardStorage": "v1",
"serviceName": "s3",
"bucketName": "my-secure-bucket",
"key": "b866d33e-eb03-41c8-b5f9-10496acf9caf",
"filename": "my-image.png",
"contentType": "image/png",
"size": 20165
}
]
```
If you upload your files on a `text` field, it will contain a stringified version of the above format. For `json` or `jsonb` columns, the actual `array of objects` will be stored.
*Even if you only upload a single file*, it will be stored as an `array` with one object. Here's the format of the object representing each uploaded file:
- `flashboardStorage` *(string)*: the version of the format. Currently, it will always be `v1`, and we don't intend to make new versions anytime soon. But we have it there just in case we need to make any breaking changes to the stored format.
- `serviceName` *(string)*: the service used to upload the file. Currently, it will always be `s3`, since we only support S3-compatible storage services at the moment. But we plan to add other services in the future.
- `bucketName` *(string)*: the name of the bucket where the file is stored.
- `key` *(string)*: the key of the object in your bucket in UUID format.
- `filename` *(string)*: the original name of the uploaded file.
- `contentType` *(string)*: the [Content-Type](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Content-Type) of the file.
- `size` *(number)*: the size of the file in bytes.
All this information allows you to render your images by connecting to your storage service and generating a signed URL. [Follow this guide](https://medium.com/@aidan.hallett/securing-aws-s3-uploads-using-presigned-urls-aa821c13ae8d) for in-depth instructions, but here's a simple example in TypeScript using [Zod](https://zod.dev/) and [**@aws-sdk/client-s3**](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-s3/):
```ts
const fileSchema = z.object({
bucketName: z.string(),
key: z.string(),
contentType: z.string(),
})
const filesSchema = z.array(fileSchema)
function loadMyFilesField() {
// Here you would load the field from the database instead
const myFilesValue = [
{
bucketName: 'my-secure-bucket',
ket: '001b8672-76cf-4f6e-9950-798ca09b68bc',
contentType: 'image/png',
},
{
bucketName: 'my-secure-bucket',
ket: 'b866d33e-eb03-41c8-b5f9-10496acf9caf',
contentType: 'application/pdf',
},
]
return filesSchema.parse(myFilesValue)
}
const myFiles = loadMyFilesField()
const client = new S3Client({
endpoint: 'https://s3.us-east-2.amazonaws.com',
region: 'us-east-2',
credentials: {
accessKeyId: 'my-access-key-id',
secretAccessKey: 'my-secret-access-key',
},
})
myFiles.forEach((file) => {
const { bucketName, key, contentType } = file
const command = new GetObjectCommand({
Bucket: bucketName,
Key: key,
})
// For images, set ResponseContentDisposition to inline for browser rendering
// For other files, set to attachment for immediate download
const disposition = contentType.startsWith('image/') ? 'inline' : 'attachment'
command.input.ResponseContentType = contentType
command.input.ResponseContentDisposition = disposition
// Generate a signed URL that's valid for 15 minutes
const url = getSignedUrl(client, command, { expiresIn: 60 * 15 })
console.log('URL', url)
})
```
---
TABS
---
# Edit tab name and order
You can change a tab name or its order. Open a panel to see a list of its tabs on the left side.
### Edit tab name
Hover over a tab and click the gear icon.
You'll see a form to update the tab name.
### Change tab order
Your tabs will be ordered alphabetically by default when creating a new panel.
To change the order, hover over a tab name, click, and drag it.
Note: these features are available only on large screens (desktop).
---
# Add new tables
You added a new table to your database, but it's not showing up in Flashboard. Don't worry, nothing's broken. You just need to add it as a tab.
### Why new tables don't appear automatically
When you first create a panel, Flashboard reads your database schema and generates a tab for each table. But after that initial setup, it stops syncing automatically.
Why? Because you've probably customized things. You may have renamed tabs to be more readable, reordered them to match your workflow, or removed ones you don't need. If Flashboard auto-synced every time your schema changed, it would overwrite all that work.
So when you add a new table to your database, Flashboard leaves your existing tabs alone and lets you decide whether to add the new one.
### Which tables get tabs?
When creating a panel, Flashboard generates tabs for tables that have a PRIMARY KEY constraint. It also skips common framework tables to keep your panel clean:
- Migration tables (`prisma_migrations`, `knex_migrations`, etc.)
- Session tables (`sessions`, `user_sessions`, etc.)
- Background job tables (`delayed_jobs`, `good_jobs`, etc.)
- Auth framework tables (`oauth_access_tokens`, `password_resets`, etc.)
### How to add a new table
1. Open your panel
2. Click **+ New tab** at the bottom of the tabs list
3. Select your new table from the dropdown
The dropdown shows all tables with PRIMARY KEY constraints and views from all schemas. It includes the tables that were excluded during initial panel creation, so you can add them if you wish to. Views are read-only.
4. Use the default tab name or change it, and click **OK**
Your new table is now a tab, ready to use.
---
# Fix column errors
You renamed or deleted a column in your database, and now you see an error like "Field 'name' not found in database (Table settings)" when trying to load a tab. To solve it, just click the `Manage tab` button and follow the warnings Flashboard give you.
This happens because Flashboard stores your field configuration separately from your database schema. When the schema changes, the configuration needs to catch up.
### How to fix it
Each warning has a **Fix it** button that takes you directly to the settings where that field is configured. You can also get there through the **Build** menu in the top right corner.
In the settings, you'll see the orphaned field marked as "not on db". Toggle it off to remove it from your configuration.
If you renamed the column instead of deleting it, you can add the new column from the available fields list below.
---
PANELS
---
# Update connection URL
If your database credentials change, you need to update your panel's connection URL. Go to the [manage panels](https://www.getflashboard.com/manage/panels) page. It's the home page when you are signed in.
Find your panel on the list, then click the database icon.
Paste your new connection URL and confirm your password.
---
# Manage panels
You can see and manage your panels by clicking on the settings icon, then [Panels](https://www.getflashboard.com/manage/panels). It's also the home page when you are signed in.
There you see a list of your panels grouped by team and organization. Clicking on a panel's card will take you to the panel itself.
Click the database icon to update your panel's connection URL.
Click the list item to view the panel's logs.
Click the pencil icon to change your panels's name and slug or select a different namespace.
Click the trash can icon to delete it. **Caution**: this action is irreversible. It will delete the panel, its tabs, saved filters, and all its customizations.
---
TEAMS
---
# Invite team members
Go to your list of teams by clicking on the settings icon, then [Teams](https://www.getflashboard.com/manage/teams).
There you see a list of your teams grouped by organization. Click the card of the team you wish to invite members to.
Type the email of the person you want to invite in the input field and select a role. The three roles are:
- **Editor**: Can use panels as configured by builders and owners.
- **Builder**: Can configure panels and tabs, decide what can be viewed or edited, as well as anything editors can do.
- **Owner**: Can create panels and invite other team members, as well as anything builders can do.
The invited person will receive an email to accept the invitation. After sending the invite, you'll see a list of pending invitations. You can resend the invitation or delete it from this list.
Note: You need a [Starter subscription](https://www.getflashboard.com/pricing) or higher to invite team members.
---
# Manage teams
Flashboard creates a default team for you when you sign up. You can see and manage your teams by clicking on the settings icon, then [Teams](https://www.getflashboard.com/manage/teams).
There you see a list of your teams grouped by organization. You can change your teams's name and slug, create a new one, or delete it.
You can click a team's card to see its details. There, you can require two-factor authentication (2FA) for all its members, invite new members, and see the member list.
Note: You need a [Pro subscription](https://www.getflashboard.com/pricing) or higher to create more than one team.
---
ORGANIZATIONS
---
# Manage organizations
Flashboard creates a default organization for you when you sign up. You can see and manage your organizations by clicking on the settings icon, then [Organizations](https://www.getflashboard.com/manage/organizations).
You can change your organization's name and slug, or create a new one. Be aware that subscriptions are tied to organizations.
---
ACCOUNT
---
# Subscriptions
You can see and manage your subscriptions by clicking on the settings icon, then [Subscriptions.](https://www.getflashboard.com/manage/subscriptions) There, you can upgrade, downgrade, or cancel your subscription.
Flashboard subscriptions are tied to organizations. If you have multiple organizations, you can have distinct types of subscriptions for each one.
---
# Edit profile
You can see and manage your profile by clicking on the settings icon, then [Edit profile.](https://www.getflashboard.com/manage/edit-profile)
You can only edit your first and last name. If you wish to change your email, please contact support.
---
# Two-factor authentication
You can set up two-factor authentication for your account at [Security.](https://www.getflashboard.com/manage/security)
Click on the "Enable two-factor authentication" button and follow the instructions. You'll need an authenticator app such as 1Password, Authy, or Google Authenticator.
---
COMPARISONS
---
# Flashboard vs Retool
Flashboard and Retool solve different problems. Retool is a low-code platform for building custom internal tools. Flashboard is an instant admin panel that auto-generates from your database schema. This page documents the differences and trade-offs to help you choose.
### Quick comparison
| Aspect | Flashboard | Retool |
|--------|------------|--------|
| Type | Instant admin panel and CMS | Low-code app builder |
| Setup time | Under 2 minutes | Hours to weeks |
| Technical skill required | None | JavaScript and SQL helpful |
| Database support | PostgreSQL only | 50+ databases and APIs |
| Customization | CRUD operations and CMS features | Build anything with drag-and-drop |
| Pricing model | Per team (unlimited seats on higher tiers) | Per user |
### What Flashboard does well
**Instant setup, then customize.** Connect your PostgreSQL database and get a working admin panel in under 2 minutes. Flashboard reads your schema and generates the interface automatically. From there, you can customize field labels, configure which columns are visible or editable, set up team permissions, define foreign key display labels, and more.
**Unlimited seats on higher tiers.** Flashboard's Team and Pro plans include unlimited seats, so you can add your entire team without the cost scaling per person. Retool charges per user, which adds up quickly as your team grows.
**CMS built in.** Write and edit rich text content with a Notion-like editor. Edit images, upload files to your storage service, and manage content alongside your application data.
**End-to-end credential encryption.** Your database credentials are encrypted with a key only you own. Even Flashboard's team cannot access them.
**PostgreSQL-specific features.** Search JSON columns, navigate between tables using foreign keys, and take advantage of PostgreSQL's capabilities directly in the interface.
**Safe for non-technical users.** Configure what each team can see and edit, down to the column level. Non-technical team members can work confidently without risk of breaking things.
### What Retool does well
**Build any internal tool.** Retool is a platform for building custom applications. Dashboards, charts, approval workflows, multi-step forms, complex business logic — if you can design it, you can build it.
**50+ integrations.** Connect to PostgreSQL, MySQL, MongoDB, REST APIs, GraphQL, Salesforce, Stripe, and dozens more. Retool works with almost any data source.
**Drag-and-drop component library.** Tables, charts, forms, buttons, modals, tabs — Retool provides pre-built components you can customize with JavaScript and CSS.
**Workflow automation.** Build automated workflows with triggers, conditions, and actions. Replace cron jobs and manual processes with visual automation.
**Mobile app support.** Build mobile-friendly internal tools that work on phones and tablets, not just desktop browsers.
**Enterprise compliance.** SOC 2 Type II compliance, SSO, and additional enterprise features for large organizations with strict security requirements.
### When to choose Flashboard
- You need an admin panel or CMS now, not in a few weeks
- You have a growing team and want predictable pricing with unlimited seats
- Non-technical team members need to manage data
- You're working exclusively with PostgreSQL
- You don't need dashboards, charts, or custom workflows
- You want to avoid building and maintaining internal tools
### When to choose Retool
- You need dashboards, charts, or data visualization
- You need to connect multiple database types or external APIs
- You have engineering resources to build and maintain custom tools
- You need complex workflows, approvals, or business logic
- You need mobile app support
- You require specific enterprise compliance certifications
### Frequently asked questions
#### Is Retool worth it for an early-stage startup?
It depends on what you need. If you need a straightforward admin panel for CRUD operations and content management, Retool's per-user pricing and development time may not be worth it. If you need custom dashboards, charts, or complex workflows that Flashboard doesn't support, Retool's investment makes more sense.
#### What are the best Retool alternatives for small startups?
For small startups needing a PostgreSQL admin panel, Flashboard is a direct alternative that requires no development time. Other alternatives include Appsmith (open source, more technical), Forest Admin (similar instant approach), and building custom with React Admin or Refine (requires engineering resources).
#### Should I build or buy an admin panel?
Building a custom admin panel typically takes weeks of engineering time. For most teams, that time is better spent on user-facing features. Tools like Flashboard or Retool let you skip that work entirely — the question is which approach fits your needs. Flashboard for instant CRUD and CMS, Retool for custom internal applications.
#### Can I migrate from Retool to Flashboard?
If your Retool usage is primarily CRUD operations and basic data management, migrating to Flashboard is straightforward — just connect your database. If you've built custom dashboards, charts, or workflows in Retool, those features don't have equivalents in Flashboard and would need alternative solutions.
#### Can I migrate from Flashboard to Retool?
Yes. Since Flashboard doesn't modify your database schema, you can connect Retool to the same database at any time. If your needs grow beyond what Flashboard offers, transitioning to Retool (or any other tool) is straightforward.
### Still not sure?
If you're primarily managing data in a PostgreSQL database and don't need custom dashboards or workflows, [try Flashboard for free](https://www.getflashboard.com/auth). If you need to build custom internal applications with complex logic, [explore Retool](https://retool.com). Both offer free tiers, so you can evaluate each without commitment.
---
# Flashboard vs DBeaver
Flashboard and DBeaver are different categories of tools. DBeaver is a desktop database IDE for developers who write SQL. Flashboard is a web-based admin panel that generates a UI from your database schema. This page documents the differences and trade-offs to help you choose.
### Quick comparison
| Aspect | Flashboard | DBeaver |
|--------|------------|---------|
| Type | Web-based admin panel and CMS | Desktop database IDE |
| Target user | Teams including non-technical members | Developers and DBAs |
| Primary purpose | Data management through a UI | SQL querying and database development |
| Setup | Connect a database URL | Download and install on each computer |
| Database support | PostgreSQL only | 100+ databases |
| SQL required | No | Yes |
| Team access | Built-in permissions, shared via browser | Separate installation per user |
| Pricing model | SaaS with free tier, unlimited seats on higher plans | Free Community edition, PRO from $10/month |
### What Flashboard does well
**No SQL required.** Non-technical team members can search, filter, create, and edit records without writing queries. The interface handles everything.
**Instant setup.** Connect your PostgreSQL database and get a working admin panel in under 2 minutes. No installation, no configuration files.
**Built for teams.** Share access through a browser link. Configure what each team can see and edit, down to the column level. No need to install software on everyone's computer.
**Safer for non-technical users.** With a database IDE, anyone can run `DELETE FROM users` or an unoptimized query that locks your tables. Flashboard constrains actions to what the UI allows, with permissions controlling who can edit what. Non-technical team members can work confidently without risk of breaking things.
**Connection pooling built in.** Flashboard manages database connections centrally. With DBeaver, each user creates their own connections, which can exhaust your PostgreSQL connection limit as your team grows.
**Unlimited seats on higher tiers.** Add your entire team without per-user costs adding up.
**CMS features included.** Write and edit rich text content with a Notion-like editor. Upload images and files to your storage service.
### What DBeaver does well
**Full SQL access.** Write and execute any SQL query. DBeaver is a complete development environment for database work.
**100+ database support.** Connect to PostgreSQL, MySQL, MongoDB, Oracle, SQL Server, and many more. DBeaver works with almost any database.
**Schema development tools.** Design tables, create ER diagrams, compare schemas between databases, and visualize table relationships.
**Advanced query features.** Syntax highlighting, auto-completion, query history, explain plans, and result set visualization. DBeaver is built for developers who spend their day writing SQL.
**Free and open source.** The Community edition is completely free under Apache 2.0. No account required, no usage limits.
**Works offline.** As a desktop application, DBeaver doesn't need an internet connection to access your database.
### When to choose Flashboard
- Non-technical team members need to manage data
- You want to avoid teaching SQL to support or ops staff
- You need a quick admin panel without building anything
- You're working exclusively with PostgreSQL
- You want browser-based access with team permissions
- You prefer predictable pricing as your team grows
### When to choose DBeaver
- You or your team write SQL daily
- You need to connect to multiple database types
- You need schema design and development tools
- You want a free, open-source solution
- You need offline database access
- You're a developer or DBA who prefers a desktop IDE
### Frequently asked questions
#### Can I use DBeaver as an admin panel for my team?
DBeaver is designed for developers who write SQL, not as a team admin panel. Giving DBeaver access to non-technical team members creates real risks: they could accidentally delete data, run queries that lock tables, or execute unoptimized queries that slow down your production database. There's also an operational cost: each DBeaver installation creates its own database connections, and DBAs often spend hours per week killing idle connections to free up resources. For teams that include non-developers, a dedicated admin panel provides both a safer interface and centralized connection management.
#### Is DBeaver good for non-technical users?
No. DBeaver requires SQL knowledge and gives users direct access to run any query against your database. A typo in a WHERE clause can delete the wrong records. An unfiltered SELECT on a large table can lock resources. Non-technical users need guardrails that database IDEs don't provide. If your team includes people who just need to look up a customer record or update a field, use a tool that constrains what's possible.
#### Should I use a database IDE or an admin panel tool?
It depends on who needs access and what they need to do. Database IDEs like DBeaver are for developers who write SQL and need full control over the database. Admin panels like Flashboard are for teams who need to view and edit data without writing queries. Many teams use both: DBeaver for development work, and an admin panel for day-to-day data management.
#### Can my support team use DBeaver to manage customer data?
This is risky. Support staff would have direct SQL access to your production database. One wrong query could delete customer data, corrupt records, or take down your application. You'd also need to distribute database credentials to each person and manage connection limits as your support team grows. Admin panels are designed for exactly this use case: they provide search and edit interfaces with built-in permissions, so support staff can do their job without the ability to accidentally break things.
#### Why does DBeaver keep exhausting my PostgreSQL connection limit?
Each DBeaver installation opens its own database connections, and users often leave connections open when they're not actively querying. With a growing team, you can quickly hit PostgreSQL's default connection limit. DBAs frequently spend time killing idle DBeaver connections to free up resources. Web-based admin panels avoid this by managing connections centrally through a shared pool.
#### Can I migrate between these tools?
These tools serve different purposes, so "migration" doesn't quite apply. You can use both simultaneously: DBeaver for development and database administration, Flashboard for team data management. Neither modifies your database schema in ways that would prevent using the other.
### Still not sure?
If you're a developer who needs SQL access and database development tools, [download DBeaver](https://dbeaver.io). If you need a team-friendly admin panel that works without SQL, [try Flashboard for free](https://www.getflashboard.com/auth). Many teams use both.
---
# Flashboard vs Appsmith
Flashboard and Appsmith solve similar problems in different ways. Appsmith is an open-source low-code platform for building custom internal tools. Flashboard is an instant admin panel that auto-generates from your database schema. This page documents the differences and trade-offs to help you choose.
### Quick comparison
| Aspect | Flashboard | Appsmith |
|--------|------------|----------|
| Type | Instant admin panel and CMS | Low-code app builder |
| Setup time | Under 2 minutes | Hours to weeks |
| Technical skill required | None | JavaScript and SQL helpful |
| Database support | PostgreSQL only | 50+ databases and APIs |
| Customization | CRUD operations and CMS features | Build anything with drag-and-drop |
| Pricing model | Per team (unlimited seats on higher tiers) | Per user |
| Self-hosting | Cloud only | Yes (open source, Apache 2.0) |
| SOC 2 Type II | No | Yes |
### What Flashboard does well
**Instant setup, then customize.** Connect your PostgreSQL database and get a working admin panel in under 2 minutes. Flashboard reads your schema and generates the interface automatically. From there, you can customize field labels, configure which columns are visible or editable, set up team permissions, define foreign key display labels, and more.
**Unlimited seats on higher tiers.** Flashboard's Team and Pro plans include unlimited seats, so you can add your entire team without the cost scaling per person. Appsmith charges per user, which adds up as your team grows.
**CMS built in.** Write and edit rich text content with a Notion-like editor. Edit images, upload files to your storage service, and manage content alongside your application data.
**End-to-end credential encryption.** Your database credentials are encrypted with a key only you own. Even Flashboard's team cannot access them.
**Safe for non-technical users.** Configure what each team can see and edit, down to the column level. Non-technical team members can work confidently without risk of breaking things or needing to learn JavaScript.
**No maintenance required.** Flashboard is a managed service. No servers to maintain, no updates to deploy, no infrastructure to manage. Appsmith self-hosted deployments require ongoing maintenance.
### What Appsmith does well
**Open source and self-hostable.** Appsmith is Apache 2.0 licensed. You can inspect the code, contribute, and run it on your own infrastructure. For organizations with strict data residency requirements or air-gapped environments, self-hosting is essential.
**Build any internal tool.** Appsmith is a platform for building custom applications. Dashboards, charts, approval workflows, multi-step forms, complex business logic. If you can design it, you can build it with drag-and-drop widgets and JavaScript.
**50+ integrations.** Connect to PostgreSQL, MySQL, MongoDB, REST APIs, GraphQL, Salesforce, Stripe, and dozens more. Appsmith works with almost any data source.
**Workflow automation.** Build automated workflows with triggers, conditions, and actions. Replace cron jobs and manual processes with visual automation.
**SOC 2 Type II certified.** For organizations that require specific compliance certifications, Appsmith has them. Flashboard does not currently have SOC 2 certification.
**Full code control.** Write custom JavaScript for complex logic, style components with CSS, and extend functionality beyond what pre-built widgets offer. Developers get full control over behavior and appearance.
### When to choose Flashboard
- You need an admin panel or CMS now, not in a few weeks
- You have a growing team and want predictable pricing with unlimited seats
- Non-technical team members need to manage data without learning JavaScript
- You're working exclusively with PostgreSQL
- You don't need dashboards, charts, or custom workflows
- You want to avoid building and maintaining internal tools
### When to choose Appsmith
- You need to build custom internal tools beyond basic CRUD
- You need to connect multiple database types or external APIs
- Self-hosting is a requirement for your organization
- You have engineering resources to build and maintain custom applications
- You need complex workflows, approvals, or business logic
- You require SOC 2 Type II compliance certification
### Frequently asked questions
#### Is Appsmith worth it for an early-stage startup?
It depends on what you need. If you need a straightforward admin panel for CRUD operations and content management, Appsmith's development time and per-user pricing may not be worth it. If you need custom dashboards, workflows, or integrations that Flashboard doesn't support, Appsmith's flexibility makes sense. Many startups start with simpler tools and move to low-code platforms as their needs grow more complex.
#### What are the best Appsmith alternatives?
For low-code internal tool builders: Retool, Budibase, and Tooljet. For instant admin panels that don't require building: Flashboard and Forest Admin. The right alternative depends on whether you want to build custom tools or get something working immediately.
#### Can I use Appsmith as an instant admin panel?
Appsmith can create admin panels, but they aren't instant. You'll need to configure data sources, build table views, create forms, and wire up the logic. This gives you more control but takes more time. If you primarily need CRUD operations with minimal setup, dedicated admin panel tools are faster to deploy.
#### Should I self-host Appsmith or use Flashboard?
Self-hosting makes sense if you have strict data residency requirements, need air-gapped deployment, or want to avoid recurring SaaS costs at scale. It requires infrastructure expertise and ongoing maintenance. Flashboard is managed, so there's nothing to maintain, but you're trusting a third party with your database credentials (encrypted end-to-end with a key only you own).
#### Can I migrate from Appsmith to Flashboard?
If your Appsmith usage is primarily CRUD operations and basic data management, migrating to Flashboard is straightforward. Just connect your database. If you've built custom dashboards, workflows, or complex applications in Appsmith, those don't have equivalents in Flashboard and would need alternative solutions.
#### Can I migrate from Flashboard to Appsmith?
Yes. Since Flashboard doesn't modify your database schema, you can connect Appsmith to the same database at any time. If your needs grow beyond what Flashboard offers, transitioning to Appsmith (or any other tool) is straightforward. Note that you'll need to rebuild any interfaces from scratch in Appsmith.
#### Which is better for non-technical team members?
Flashboard is designed for users who don't know SQL or JavaScript. The interface auto-generates from your schema, and team members can search, view, and edit records without any training. Appsmith requires someone technical to build the interface first. Once built, the resulting application can be simple enough for non-technical users, but building it requires development skills.
#### Is Appsmith really free?
Appsmith's Community Edition is free and open source (Apache 2.0). You can self-host it without paying license fees. The free cloud tier includes up to 5 users. Paid tiers add features like unlimited workspaces, premium integrations, SSO, audit logs, and priority support. For larger teams or enterprise requirements, expect per-user costs.
### Still not sure?
If you need an admin panel for managing data in a PostgreSQL database without building anything, [try Flashboard for free](https://www.getflashboard.com/auth). If you need to build custom internal tools with full code control and self-hosting options, [explore Appsmith](https://www.appsmith.com). Both offer free tiers, so you can evaluate each without commitment.
---
# Flashboard vs Budibase
Flashboard and Budibase solve similar problems in different ways. Budibase is an open-source low-code platform for building custom internal tools. Flashboard is an instant admin panel that auto-generates from your database schema. This page documents the differences and trade-offs to help you choose.
### Quick comparison
| Aspect | Flashboard | Budibase |
|--------|------------|----------|
| Type | Instant admin panel and CMS | Low-code app builder |
| Setup time | Under 2 minutes | Hours to days |
| Technical skill required | None | Some coding helpful |
| Database support | PostgreSQL only | PostgreSQL, MySQL, MongoDB, MSSQL, and more |
| Customization | CRUD operations and CMS features | Build custom apps with drag-and-drop |
| Pricing model | Per team (unlimited seats on higher tiers) | Per creator + per user |
| Self-hosting | Cloud only | Yes (open source, Apache 2.0) |
| Compliance | No SOC 2 | ISO 27001 certified |
### What Flashboard does well
**Instant setup, then customize.** Connect your PostgreSQL database and get a working admin panel in under 2 minutes. Flashboard reads your schema and generates the interface automatically. From there, you can customize field labels, configure which columns are visible or editable, set up team permissions, define foreign key display labels, and more.
**Unlimited seats on higher tiers.** Flashboard's Team and Pro plans include unlimited seats, so you can add your entire team without the cost scaling per person. Budibase charges per creator plus per app user, which adds up as your team and apps grow.
**CMS built in.** Write and edit rich text content with a Notion-like editor. Edit images, upload files to your storage service, and manage content alongside your application data.
**End-to-end credential encryption.** Your database credentials are encrypted with a key only you own. Even Flashboard's team cannot access them.
**Safe for non-technical users.** Configure what each team can see and edit, down to the column level. Non-technical team members can work confidently without risk of breaking things or needing to learn JavaScript.
**No maintenance required.** Flashboard is a managed service. No servers to maintain, no updates to deploy, no infrastructure to manage. Budibase self-hosted deployments require ongoing maintenance and security patching.
### What Budibase does well
**Open source and self-hostable.** Budibase is Apache 2.0 licensed. You can inspect the code, contribute, and run it on your own infrastructure. For organizations with strict data residency requirements or air-gapped environments, self-hosting is essential. The self-hosted free tier supports up to 20 users.
**Build any internal tool.** Budibase is a platform for building custom applications. Forms, portals, approval workflows, multi-step processes, custom business logic. If you can design it, you can build it with drag-and-drop components.
**Multiple database support.** Connect to PostgreSQL, MySQL, MongoDB, MSSQL, Google Sheets, Snowflake, and more. Budibase works with most data sources your organization might use.
**Automation workflows.** Build automated workflows with triggers, conditions, and actions. Replace cron jobs and manual processes with visual automation that runs on schedule or in response to events.
**Budibase AI.** Use AI to help build apps faster within the Budibase platform (available on cloud plans).
**ISO 27001 certified.** For organizations that require specific compliance certifications, Budibase has ISO 27001. Flashboard does not currently have SOC 2 or ISO 27001 certification.
**Plugin ecosystem.** Extend Budibase with custom components and data sources through plugins. The community contributes additional functionality you can install and use.
### When to choose Flashboard
- You need an admin panel or CMS now, not in days or weeks
- You have a growing team and want predictable pricing with unlimited seats
- Non-technical team members need to manage data without learning JavaScript
- You're working exclusively with PostgreSQL
- You don't need custom workflows, forms, or app building
- You want to avoid building and maintaining internal tools
### When to choose Budibase
- You need to build custom internal tools beyond basic CRUD
- You need to connect multiple database types
- Self-hosting is a requirement for your organization
- You have technical resources to build and maintain custom applications
- You need automation workflows, approval processes, or complex forms
- You want open source with community contributions and plugin support
### Frequently asked questions
#### Is Budibase worth it for an early-stage startup?
It depends on what you need. If you need a straightforward admin panel for CRUD operations and content management, Budibase's development time and per-user pricing may not be worth it. If you need custom internal tools, automation workflows, or multi-database support that Flashboard doesn't offer, Budibase's flexibility makes sense. Many startups start with simpler tools and move to low-code platforms as their internal tooling needs grow.
#### What are the best Budibase alternatives?
For low-code internal tool builders: Retool, Appsmith, and Tooljet. For instant admin panels that don't require building: Flashboard and Forest Admin. The right alternative depends on whether you want to build custom tools or get something working immediately without development.
#### Can I use Budibase as an instant admin panel?
Budibase can create admin panels, but they aren't instant. You'll need to configure data sources, build table views, create forms, and wire up the logic. This gives you more control but takes more time. If you primarily need CRUD operations with minimal setup, dedicated admin panel tools are faster to deploy.
#### Should I self-host Budibase or use Flashboard?
Self-hosting Budibase makes sense if you have strict data residency requirements, need air-gapped deployment, or want to avoid recurring SaaS costs at scale. It requires infrastructure expertise and ongoing maintenance. Flashboard is managed, so there's nothing to maintain, but you're trusting a third party with your database connection (credentials are encrypted end-to-end with a key only you own).
#### Can I migrate from Budibase to Flashboard?
If your Budibase usage is primarily CRUD operations and basic data management on PostgreSQL, migrating to Flashboard is straightforward. Just connect your database. If you've built custom apps, workflows, or forms in Budibase, those don't have equivalents in Flashboard and would need alternative solutions. Budibase also supports databases Flashboard doesn't, so you'd be limited to PostgreSQL.
#### Can I migrate from Flashboard to Budibase?
Yes. Since Flashboard doesn't modify your database schema, you can connect Budibase to the same database at any time. If your needs grow beyond what Flashboard offers, transitioning to Budibase (or any other tool) is straightforward. Note that you'll need to build interfaces from scratch in Budibase, and CMS features would need a different solution.
#### Which is better for non-technical team members?
Flashboard is designed for users who don't know SQL or JavaScript. The interface auto-generates from your schema, and team members can search, view, and edit records without training. Budibase requires someone technical to build the interface first. Once built, the resulting application can be simple enough for non-technical users, but building it requires development skills and ongoing maintenance.
#### Is Budibase really free?
Budibase's Community Edition is free and open source (Apache 2.0). You can self-host it with up to 20 users without paying license fees. The cloud free tier includes up to 5 users. Paid tiers add features like unlimited users, Budibase AI, custom branding, and enterprise support. Pricing is per creator (people who build apps) plus per app user (people who use them), so costs scale with both builders and end users.
#### How does Budibase pricing compare to Flashboard?
Budibase charges per creator plus per app user. Flashboard charges per team with unlimited seats on higher tiers. For small teams, both have accessible entry points. As your team grows, Flashboard's unlimited seats model becomes more predictable since adding users doesn't increase costs. Budibase's model means costs scale with both the number of builders and the number of people using the apps they create.
### Still not sure?
If you need an admin panel for managing data in a PostgreSQL database without building anything, [try Flashboard for free](https://www.getflashboard.com/auth). If you need to build custom internal tools with open-source flexibility and self-hosting options, [explore Budibase](https://budibase.com). Both offer free tiers, so you can evaluate each without commitment.
---
# Flashboard vs Directus
Flashboard and Directus are both content management systems, but they take fundamentally different architectural approaches. Flashboard is a database-first CMS — your PostgreSQL database is your CMS, and you query it directly. Directus is an API-first headless CMS that generates REST and GraphQL APIs from your database. This page documents the differences and trade-offs to help you choose.
### Quick comparison
| Aspect | Flashboard | Directus |
|--------|------------|----------|
| Type | Database-first CMS | API-first headless CMS |
| Content access | Query your database directly | Via generated REST/GraphQL APIs |
| Setup time | Under 2 minutes | Longer (more configuration) |
| Database support | PostgreSQL only | Multiple databases |
| Technical skill required | None | Moderate |
| Self-hosting | No (cloud only) | Yes (free for companies under $5M revenue) |
| Content editing | Notion-like rich text editor | Data Studio with visual editing, AI tools |
| Digital asset management | Basic uploads to your storage | Full DAM with transformations and metadata |
| Automation | No built-in workflows | Automation builder |
| Pricing model | Per team (unlimited seats on higher tiers) | Per Studio User + database entries + API calls |
### What Flashboard does well
**Database-first simplicity.** Flashboard connects to your PostgreSQL database and generates a CMS interface automatically. There's no API layer between your database and your application — you query your database directly with SQL or your ORM. Your database is your single source of truth.
**Instant setup.** Connect your PostgreSQL database and get a working CMS in under 2 minutes. No configuration files, no deployment steps. Flashboard reads your schema and generates the interface automatically.
**Content and data in one place.** Unlike traditional headless CMSs that store content separately, Flashboard manages content directly in your existing database tables. Your blog posts, product descriptions, and application data live together.
**Notion-like rich text editor.** Write and edit content with a familiar block-based editor. The content is stored as clean HTML in your database columns, ready to render in your application without transformation.
**Unlimited seats on higher tiers.** Flashboard's Team and Pro plans include unlimited seats. Directus Cloud charges per Studio User, which adds up as your team grows.
**No technical knowledge required.** Connect your database and start managing content. Non-technical team members can work confidently without training.
**End-to-end credential encryption.** Your database credentials are encrypted with a key only you own. Even Flashboard's team cannot access them.
### What Directus does well
**API generation.** Directus automatically generates REST and GraphQL APIs from your database. If you need to serve content to multiple frontends — a web app, mobile app, and marketing site — Directus provides a unified API layer for all of them.
**Self-hosting option.** Directus can be self-hosted for free if your company has less than $5 million in total annual finances. For organizations that cannot use cloud services or need data residency control, this is a significant advantage.
**Multiple database support.** Directus works with PostgreSQL, MySQL, MariaDB, SQLite, MS SQL Server, and more. If you work with multiple database types, Directus handles them from one interface.
**Full digital asset management.** Directus includes a complete DAM system with on-the-fly image transformations, automatic metadata extraction, tagging, and organization. Flashboard offers basic uploads to your storage service, but Directus's DAM is more comprehensive.
**Automation workflows.** Build multi-step processes with triggers, conditions, and actions. Schedule content publishing, send notifications, or integrate with external services — all without code.
**AI-powered content tools.** Directus includes AI features for draft generation, SEO recommendations, and image creation directly in the content editing experience.
**Extensibility.** Build custom interfaces, hooks, and endpoints with Directus's extension framework. If you need functionality beyond the core product, you can build it.
### When to choose Flashboard
- You have an existing PostgreSQL database and want a CMS now
- You query your database directly and don't need an API layer
- You want content and application data in the same database
- You want the fastest possible setup with minimal configuration
- Non-technical team members need to manage content
- You want predictable per-team pricing with unlimited seats
### When to choose Directus
- You need REST/GraphQL APIs to serve content to multiple frontends
- You need self-hosting (data cannot leave your infrastructure)
- You work with multiple database types
- You need advanced digital asset management with transformations
- You need automation workflows for content operations
- You have developers to configure and maintain the platform
### Frequently asked questions
#### Are Flashboard and Directus the same type of tool?
Both are content management systems, but they take different approaches. Flashboard is database-first: your PostgreSQL database is your CMS, and you query it directly. Directus is API-first: it generates REST and GraphQL APIs that sit between your database and your applications. The right choice depends on how you want to access your content.
#### Is Directus worth it for an early-stage startup?
It depends on your architecture. If you're building multiple frontends (web, mobile, marketing site) that all need the same content via API, Directus makes sense. If you have a single application that queries your database directly, Flashboard's simpler approach may be faster to set up and easier to maintain.
#### What are the best Directus alternatives?
For teams that only need PostgreSQL support and prefer querying their database directly, Flashboard is a simpler alternative. Other headless CMS options include Strapi (open source, self-hosted), Sanity (real-time collaboration), and Contentful (enterprise-focused). Each has different trade-offs around pricing, hosting, and features.
#### Can I migrate from Directus to Flashboard?
If your content is in a PostgreSQL database that Directus connects to, you can connect Flashboard to the same database. The migration complexity depends on whether your applications query Directus's API or the database directly. If they use the API, you'd need to update them to query the database instead.
#### Can I migrate from Flashboard to Directus?
Yes. Since Flashboard doesn't modify your database schema, you can connect Directus to the same database at any time. If your needs grow to require API generation, multi-database support, or self-hosting, transitioning to Directus is possible.
#### Are both Flashboard and Directus headless CMSs?
Yes. "Headless" simply means separating content management from content presentation — there's no built-in frontend. Both Flashboard and Directus are headless by this definition. The difference is how you access your content: Flashboard lets you query your database directly, while Directus generates REST/GraphQL APIs. Direct database queries are simpler if you have one application. APIs are useful if you're serving content to multiple frontends or third parties.
### Still not sure?
If you have a PostgreSQL database and prefer querying it directly without an API layer, [try Flashboard for free](https://www.getflashboard.com/auth). If you need REST/GraphQL APIs, self-hosting, or multi-database support, [explore Directus](https://directus.io). Both offer free tiers, so you can evaluate each without commitment.
---
# Flashboard vs Forest Admin
Flashboard and Forest Admin both generate admin panels from your database. Forest Admin offers more customization and enterprise features, while Flashboard focuses on simplicity and speed. This page documents the differences and trade-offs to help you choose.
### Quick comparison
| Aspect | Flashboard | Forest Admin |
|--------|------------|--------------|
| Type | Instant admin panel | Customizable admin platform |
| Setup time | Under 2 minutes | Hours (more configuration required) |
| Target audience | Startups, small teams, non-technical users | Enterprise, teams with developers |
| Technical skill required | None | Moderate (code for customization) |
| Database support | PostgreSQL only | PostgreSQL, MySQL, MariaDB, MSSQL, MongoDB |
| Customization | UI configuration | Code-based Smart Actions, visual workflows |
| Self-hosting | No | Available (data never leaves your infrastructure) |
| Pricing model | Per team (unlimited seats on higher tiers) | Per user |
### What Flashboard does well
**Instant setup.** Connect your PostgreSQL database and get a working admin panel in under 2 minutes. No configuration files, no deployment steps. Flashboard reads your schema and generates the interface automatically.
**Unlimited seats on higher tiers.** Flashboard's Team and Pro plans include unlimited seats, so adding team members doesn't increase your costs. Forest Admin charges per user, which adds up as your team grows.
**CMS built in.** Write and edit rich text content with a Notion-like editor. Edit images, upload files to your storage service, and manage content alongside your application data.
**Simpler interface.** Flashboard is designed for non-technical users. The interface is straightforward, with less configuration required. Your support team or operations staff can start managing data without training.
**Faster time to value.** If you need an admin panel today, Flashboard delivers immediately. There's no learning curve for basic CRUD operations.
**End-to-end credential encryption.** Your database credentials are encrypted with a key only you own. Even Flashboard's team cannot access them. Forest Admin's cloud option stores your credentials on their servers; for equivalent protection, you'd need their self-hosted plan.
### What Forest Admin does well
**Multiple database support.** Forest Admin connects to PostgreSQL, MySQL, MariaDB, Microsoft SQL Server, and MongoDB. If you work with multiple database types, Forest Admin handles them all from one interface.
**Smart Actions.** Write custom business logic in your language of choice (Node.js, Python, Ruby, or PHP) that runs when users click a button. Refund an order, send a notification, trigger a workflow. Smart Actions let developers add functionality without building a separate application.
**Visual workflow builder.** Create multi-step processes with approvals, conditions, and integrations. Forest Admin's workflow builder handles complex operations that go beyond basic CRUD.
**Self-hosting option.** For organizations that cannot send data to third-party services, Forest Admin offers self-hosting. You deploy a backend server on your infrastructure, and your data never leaves your systems.
**Enterprise compliance.** Forest Admin is SOC 2 Type II certified and supports GDPR and HIPAA requirements. If you need specific compliance certifications, Forest Admin has them.
**More customization.** Forest Admin gives developers more control over the interface. Custom layouts, charts, dashboards, and integrations with external services are all possible with additional development work.
### When to choose Flashboard
- You need an admin panel now, not in hours
- You're working exclusively with PostgreSQL
- You have a growing team and want predictable per-team pricing
- You want simplicity over customization
- Non-technical users need to manage data without training
- You don't need custom workflows or business logic
### When to choose Forest Admin
- You need multiple database types (MySQL, MongoDB, etc.)
- You need custom business logic with Smart Actions
- You need self-hosting (data cannot leave your infrastructure)
- You need SOC 2 Type II or similar compliance certifications
- You have developers to configure and maintain the panel
- You need visual workflows for complex approval processes
### Frequently asked questions
#### Is Forest Admin worth it for an early-stage startup?
It depends on your needs and team. Forest Admin takes longer to set up and has a steeper learning curve. If you have developers available and need features like Smart Actions or multiple database support, the investment may be worthwhile. If you need something working today and PostgreSQL is your only database, Flashboard gets you there faster.
#### What are the best Forest Admin alternatives?
For teams that only need PostgreSQL support, Flashboard is a direct alternative with faster setup and simpler pricing. Other alternatives include Retool (more customization, higher complexity), Appsmith (open source), and building custom with frameworks like React Admin or Refine (requires significant engineering time).
#### Does Forest Admin require self-hosting?
No. Forest Admin offers both cloud and self-hosted options. The cloud version connects to your remote database similar to how Flashboard works. Self-hosting is available for organizations that need data to stay within their infrastructure, typically enterprise customers with specific compliance requirements.
#### Can I migrate from Forest Admin to Flashboard?
If your Forest Admin usage is primarily CRUD operations on a PostgreSQL database, migration is straightforward. Connect your database to Flashboard and you're running. If you've built Smart Actions, custom workflows, or connect to non-PostgreSQL databases, those features don't have equivalents in Flashboard.
#### Can I migrate from Flashboard to Forest Admin?
Yes. Since Flashboard doesn't modify your database schema, you can connect Forest Admin to the same database at any time. If your needs grow to require Smart Actions, multiple database types, or self-hosting, transitioning to Forest Admin is possible.
#### Which is more secure, Forest Admin or Flashboard?
Both take security seriously with different approaches. Flashboard encrypts your database credentials with a key only you own, meaning even Flashboard's team cannot access them. Forest Admin's cloud option stores credentials on their servers with standard enterprise encryption; their self-hosted option keeps credentials entirely on your infrastructure. Forest Admin has SOC 2 Type II certification, which Flashboard does not. The right choice depends on your requirements: if you need compliance certifications or data residency guarantees, Forest Admin's self-hosted option addresses that. If you want the convenience of a cloud service with credentials that even the provider cannot access, Flashboard's encryption model provides that.
### Still not sure?
If you're primarily managing data in a PostgreSQL database and want the fastest path to a working admin panel, [try Flashboard for free](https://www.getflashboard.com/auth). If you need multiple database types, custom Smart Actions, or self-hosting, [explore Forest Admin](https://www.forestadmin.com). Both offer free tiers, so you can evaluate each without commitment.
---
# Flashboard vs NocoDB
Flashboard and NocoDB solve different problems in the database tooling space. Flashboard is a database-first admin panel and CMS that connects to your existing PostgreSQL database. NocoDB is an open-source Airtable alternative that provides a spreadsheet-like interface for building lightweight apps and databases. This page documents the differences and trade-offs to help you choose.
### Quick comparison
| Aspect | Flashboard | NocoDB |
|--------|------------|--------|
| Type | Database-first admin panel and CMS | No-code database with spreadsheet UI |
| Primary purpose | Manage data in existing PostgreSQL | Build apps with spreadsheet interface |
| Setup time | Under 2 minutes | Varies (depends on use case) |
| Database support | PostgreSQL only | PostgreSQL, MySQL (hosted or bring your own) |
| Self-hosting | No (cloud only) | Yes (open-source, free) |
| Views | Table-focused with CRUD operations | Grid, Kanban, Gallery, Form, Calendar |
| Data access | Query your database directly | Via auto-generated REST APIs |
| Record limits | Unlimited | Based on plan (cloud version) |
| Pricing model | Per team (unlimited seats on higher tiers) | Per user with record and API limits |
| Rich text editing | Notion-like editor built in | Basic text fields |
### What Flashboard does well
**Instant setup.** Connect your PostgreSQL database and get a working admin panel in under 2 minutes. No configuration files, no designing interfaces. Flashboard reads your schema and generates the UI automatically.
**Unlimited seats on higher tiers.** Flashboard's Team and Pro plans include unlimited seats. NocoDB Cloud charges per user, which adds up as your team grows.
**No record limits.** Flashboard doesn't limit how many rows you can manage. NocoDB Cloud plans have record limits that vary by tier.
**CMS with rich text editing.** Write and edit content with a Notion-like block editor. The content is stored as HTML in your database columns, ready to render in your application. NocoDB provides basic text fields but isn't designed for content management.
**PostgreSQL specialization.** Flashboard is built specifically for PostgreSQL. It handles foreign key relationships, JSON columns, and array types natively. Instead of being a generic tool, it goes deep on PostgreSQL features.
**End-to-end credential encryption.** Your database credentials are encrypted with a key only you own. Even Flashboard's team cannot access them.
### What NocoDB does well
**Open-source and self-hostable.** NocoDB is MIT-licensed and can be self-hosted for free. For organizations that cannot use cloud services or need data residency control, this is a significant advantage.
**Multiple database support.** NocoDB works with PostgreSQL, MySQL, MariaDB, and SQLite. You can bring your own database or use NocoDB's hosted storage. If you work with multiple database types, NocoDB handles them from one interface.
**Spreadsheet-familiar interface.** NocoDB feels like Airtable or Excel. For teams who think in spreadsheets, the learning curve is minimal. Users can sort, filter, and edit records without training.
**Multiple views.** Beyond the standard grid, NocoDB offers Kanban boards for workflow visualization, Gallery view for visual content, Form view for data collection, and Calendar view for date-based organization. Flashboard focuses on table-based CRUD operations.
**API generation.** NocoDB automatically generates REST APIs from your database structure. If you need programmatic access to your data or want to build integrations, the API is ready without extra configuration.
**Airtable migration.** NocoDB can import data directly from Airtable. If you're looking for an Airtable alternative, NocoDB provides a migration path.
### When to choose Flashboard
- You have an existing PostgreSQL database and need an admin panel now
- You query your database directly and don't need an API layer
- You want a CMS with rich text editing for content management
- You want predictable per-team pricing with unlimited seats
- Non-technical team members need to manage data without training
- You want the fastest possible setup with minimal configuration
### When to choose NocoDB
- You need self-hosting (data cannot leave your infrastructure)
- You want an open-source solution you can modify
- You need multiple views (Kanban, Calendar, Gallery) for different workflows
- You're migrating from Airtable and want a familiar interface
- You work with multiple database types
- You need auto-generated APIs for integrations
### Frequently asked questions
#### Are Flashboard and NocoDB the same type of tool?
Not exactly. NocoDB is an Airtable alternative designed for building lightweight apps with a spreadsheet interface. Flashboard is an admin panel and CMS designed for managing data in existing PostgreSQL databases. NocoDB is useful when you want to create a new database with a spreadsheet UI. Flashboard is useful when you already have a PostgreSQL database and need a way to manage its data.
#### Is NocoDB worth it for managing an existing production database?
NocoDB can connect to external databases, but its strength is the spreadsheet-like interface for building new apps. If you already have a PostgreSQL production database with an established schema, Flashboard's auto-generated admin panel may be more appropriate since it's designed specifically for that use case.
#### What are the best NocoDB alternatives?
For spreadsheet-like interfaces: Airtable (the original), Baserow (open-source), and Seatable. For admin panels that connect to existing databases: Flashboard, Forest Admin, and Retool. The right alternative depends on whether you're building a new app or managing an existing database.
#### Can I migrate from NocoDB to Flashboard?
If your data is in a PostgreSQL database that NocoDB connects to, you can connect Flashboard to the same database. Flashboard reads your existing schema without requiring migrations. However, if you're using NocoDB's hosted database, you'd need to export your data to PostgreSQL first.
#### Can I migrate from Flashboard to NocoDB?
Yes. Since Flashboard doesn't modify your database schema, you can connect NocoDB to the same PostgreSQL database. If your needs evolve to require NocoDB's views (Kanban, Calendar) or self-hosting, you can transition. Note that rich text content created in Flashboard is stored as HTML, which would appear as text in NocoDB.
#### Which is better for non-technical team members?
Both tools are designed for non-technical users, but for different contexts. NocoDB provides a spreadsheet interface that feels familiar to anyone who has used Excel or Google Sheets. Flashboard provides an auto-generated admin panel with forms and tables. If your team thinks in spreadsheets, NocoDB may feel more natural. If your team needs to manage records in an existing application database, Flashboard's purpose-built interface may be clearer.
#### Should I use NocoDB or Flashboard for my startup's admin panel?
If you're building a new product and want a spreadsheet-based database to get started, NocoDB is a good choice. If you already have a PostgreSQL database powering your application and need an admin panel for your team to manage data, Flashboard is designed for that specific need. Many startups use both: NocoDB for internal project management and Flashboard for production database administration.
### Still not sure?
If you have a PostgreSQL database and need an admin panel with CMS features, [try Flashboard for free](https://www.getflashboard.com/auth). If you want an open-source spreadsheet interface with multiple views and self-hosting options, [explore NocoDB](https://nocodb.com). Both offer free tiers, so you can evaluate each without commitment.
---
# Flashboard vs JetAdmin
Even though JetAdmin used to be an admin panel creator, Flashboard and JetAdmin serve different purposes today. JetAdmin has evolved into an AI and no-code app builder for internal tools and customer portals. Flashboard is an instant admin panel and CMS focused on managing data in PostgreSQL databases. This page documents the differences and trade-offs to help you choose.
### Quick comparison
| Aspect | Flashboard | JetAdmin |
|--------|------------|----------|
| Type | Instant admin panel and CMS | AI and no-code app builder |
| Primary purpose | Data management through auto-generated UI | Build custom apps with drag-and-drop |
| Setup time | Under 2 minutes | Longer (building UI from components) |
| Database support | PostgreSQL only | 20+ databases |
| AI features | None | AI app generation from descriptions |
| CMS features | Built-in Notion-like editor, file uploads | None |
| Pricing model | Per team (unlimited seats on higher tiers) | Per-user (internal tools) or per-app (portals) |
| Custom components | No | Yes (React, Angular, Vue, HTML) |
| Workflow automation | No | Yes (5,000+ integrations) |
| Customer portals | No | Yes |
### What Flashboard does well
**Instant setup.** Connect your PostgreSQL database and get a working admin panel in under 2 minutes. No configuration files, no drag-and-drop builder, no designing interfaces. Flashboard reads your schema and generates the interface automatically.
**Simpler pricing.** Flashboard has a free tier and paid plans with unlimited seats on higher tiers. JetAdmin charges per user for internal tools and per app for customer portals, which adds up as your team or app portfolio grows.
**CMS built in.** Write and edit rich text content with a Notion-like editor. Upload images and files to your storage service. JetAdmin focuses on app building and doesn't include content management features.
**No learning curve.** There's nothing to build. Non-technical users can start searching, viewing, and editing records immediately. JetAdmin requires learning the builder interface and designing the app before anyone can use it.
**End-to-end credential encryption.** Your database credentials are encrypted with a key only you own. Even Flashboard's team cannot access them.
**PostgreSQL focus.** Flashboard is specialized for PostgreSQL. Instead of being a generic tool that works with many databases, it goes deep on PostgreSQL features like foreign key relationships, JSON columns, and array types.
### What JetAdmin does well
**20+ database support.** Connect to PostgreSQL, MySQL, MongoDB, Firebase, Supabase, BigQuery, Snowflake, and many more. If you need to manage data across multiple databases or switch between them, JetAdmin handles it from one interface.
**AI-powered app generation.** Describe what you want in natural language and JetAdmin generates a working app structure. For teams that want custom interfaces but don't want to design from scratch, this removes friction.
**Custom component development.** Build your own components using React, Angular, Vue, or plain HTML/CSS/JS. If you need highly customized interfaces beyond standard CRUD, JetAdmin gives you that flexibility.
**Workflow automation.** Trigger workflows via API calls, schedule recurring jobs, and connect to 5,000+ integrations. If your internal tools need to kick off processes beyond simple data edits, JetAdmin has that built in.
**Customer portal capabilities.** Build external-facing apps for customers, partners, or vendors. Flashboard is designed for internal team use only.
**Version control and environments.** Work on draft versions and publish when ready. Maintain separate staging and production environments. Useful for teams that need formal release processes.
**Figma-to-app workflow.** Use the Figma plugin to convert designs into production-ready apps. If your team designs in Figma, this streamlines the handoff.
### When to choose Flashboard
- You need an admin panel now, not in a few days
- You're working exclusively with PostgreSQL
- You want predictable pricing without per-seat costs
- Non-technical users need to manage data without training
- You need CMS features for content management
- You don't want to build or design any interfaces
### When to choose JetAdmin
- You need to connect multiple databases
- You want AI to generate your initial custom app
- You need custom-built workflows and automations
- You're building customer-facing portals, not just internal tools
- Your team includes developers who want to build custom components
- You need to query data from multiple sources in single views
### Frequently asked questions
#### Is JetAdmin worth it for teams that just need CRUD?
If your primary need is viewing and editing database records, JetAdmin may be more than you need. The app builder is powerful but requires design decisions and setup time. For straightforward data management, a tool that auto-generates the interface from your schema saves the effort of building custom apps.
#### What are the best JetAdmin alternatives?
For app building and internal tools: Retool, Appsmith, Budibase, and Tooljet. For admin panels with auto-generated interfaces, Flashboard is the way to go. The right alternative depends on whether you want to build custom apps or get a working interface immediately.
#### Can I use JetAdmin without coding?
Yes. JetAdmin is designed as a no-code platform. The drag-and-drop builder, AI generation, and visual workflow editor don't require writing code. However, developers can extend functionality with custom components using React, Angular, or JavaScript when needed.
#### When do I need an app builder vs an instant admin panel?
Use an app builder like JetAdmin when you need custom interfaces, multi-database views, workflow automation, or customer-facing portals. Use an instant admin panel like Flashboard when you need to manage records in a single database and want to start immediately without building anything.
#### Can I migrate from JetAdmin to Flashboard?
If you're using JetAdmin primarily for PostgreSQL CRUD operations, you can connect Flashboard to the same database. Flashboard doesn't require migration since it reads from your existing schema. However, custom apps, workflows, and integrations built in JetAdmin won't transfer since Flashboard doesn't offer those features.
#### Can I migrate from Flashboard to JetAdmin?
Yes. Since Flashboard doesn't modify your database schema, you can connect JetAdmin to the same database at any time. If your needs grow to require custom interfaces, multi-database views, or workflow automation, JetAdmin can take over. Note that you'll need to design and build the interfaces from scratch.
#### Which is better for non-technical team members?
Both tools are designed for non-technical users, but for different stages. JetAdmin requires someone to build the app first, then non-technical users can use it. Flashboard generates the interface automatically, so non-technical users can start immediately. If you have developers who will design and maintain custom apps, JetAdmin gives them flexibility. If you want your team using a tool today, Flashboard is ready out of the box.
### Still not sure?
If you need an admin panel for managing data in a PostgreSQL database, [try Flashboard for free](https://www.getflashboard.com/auth). If you need to build custom apps with AI, connect multiple databases, or create customer-facing portals, [explore JetAdmin](https://www.jetadmin.io). Both offer ways to evaluate before committing.
---
# Flashboard vs Basedash
Even though Basedash used to be an admin panel creator, Flashboard and Basedash serve different primary purposes today. Basedash is an AI-native business intelligence platform for analytics and data exploration across many data sources. Flashboard is an instant admin panel and CMS focused on managing data in PostgreSQL databases. This page documents the differences and trade-offs to help you choose.
### Quick comparison
| Aspect | Flashboard | Basedash |
|--------|------------|----------|
| Type | Instant admin panel and CMS | AI-native BI platform |
| Primary purpose | Data management through a UI | Business intelligence and analytics |
| Setup time | Under 2 minutes | Longer (more data sources to configure) |
| Database support | PostgreSQL only | 600+ data sources |
| AI features | None | AI SQL generation, natural language queries |
| CMS features | Built-in Notion-like editor | None |
| Pricing model | Free tier, unlimited seats on higher plans | Per-seat, enterprise-focused |
| Seats | Unlimited on higher tiers | 2-50 depending on plan |
| SOC 2 Type II | No | Yes |
### What Flashboard does well
**Instant setup.** Connect your PostgreSQL database and get a working admin panel in under 2 minutes. No configuration files, no complex onboarding. Flashboard reads your schema and generates the interface automatically.
**Accessible pricing.** Flashboard has a free tier and paid plans with unlimited seats on higher tiers. Basedash is priced for enterprise teams with per-seat billing. For teams that don't need analytics or multi-source data, Flashboard offers significant cost savings.
**Unlimited seats on higher tiers.** Add your entire team without per-user costs. Basedash charges based on seat count, which adds up as your team grows.
**CMS built in.** Write and edit rich text content with a Notion-like editor. Upload images and files to your storage service. Basedash focuses on analytics and doesn't include content management features.
**Simpler for non-technical users.** The interface is designed for operations and support teams who need to look up records, not write queries. No SQL knowledge required for day-to-day use.
**End-to-end credential encryption.** Your database credentials are encrypted with a key only you own. Even Flashboard's team cannot access them.
### What Basedash does well
**600+ data sources.** Connect to PostgreSQL, MySQL, Snowflake, BigQuery, Stripe, Shopify, HubSpot, Google Analytics, and hundreds more. If you need to query and visualize data across multiple platforms, Basedash handles it from one interface.
**AI-powered queries.** Ask questions in natural language and Basedash generates the SQL. For teams exploring data who don't want to write queries manually, this removes friction.
**Business intelligence focus.** Basedash is built for analytics: dashboards, charts, reports, and data exploration. If your primary goal is understanding trends and metrics rather than managing individual records, Basedash is designed for that workflow.
**SOC 2 Type II certified.** For organizations that require specific compliance certifications, Basedash has them. Flashboard does not currently have SOC 2 certification.
**Multiple data sources in one view.** Join data across different platforms without ETL pipelines. See Stripe payments alongside your PostgreSQL customers alongside your Shopify orders.
**Enterprise features.** SSO, advanced permissions, audit logs, and custom SLAs for larger organizations with specific requirements.
### When to choose Flashboard
- You need an admin panel now, not a BI platform
- You're working exclusively with PostgreSQL
- You want predictable pricing without per-seat costs
- Non-technical users need to manage data without training
- You need CMS features for content management
- Budget is a constraint (Flashboard has a free tier, Basedash is enterprise-priced)
### When to choose Basedash
- You need to query multiple data sources from one interface
- Your primary goal is analytics and business intelligence
- You want AI-generated SQL and natural language queries
- You need SOC 2 Type II compliance certification
- You have budget for enterprise tooling
- You need to combine data from SaaS tools like Stripe, Shopify, or HubSpot
### Frequently asked questions
#### Is Basedash worth the cost for an early-stage startup?
It depends on your needs. Basedash is priced for enterprise teams. If you're querying multiple data sources and need analytics dashboards, the investment may be justified. If you primarily need to manage records in a PostgreSQL database, tools like Flashboard provide that functionality at a fraction of the cost. Many startups start with simpler tools and upgrade to BI platforms as their analytics needs grow.
#### What are the best Basedash alternatives?
For business intelligence and analytics: Metabase (open source), Mode, Looker, and Tableau. For admin panels focused on data management: Flashboard, Retool, Forest Admin, and Appsmith. The right alternative depends on whether you need analytics or operational data management.
#### Can I use Basedash as an admin panel for my team?
Basedash can handle CRUD operations, but it's primarily designed for analytics and data exploration. If your team mostly needs to search, view, and edit individual records, a dedicated admin panel may provide a more focused experience. If they need to explore data, run reports, and build dashboards, Basedash is well-suited for that.
#### When do I need a BI platform vs an admin panel?
Admin panels are for operational data management: looking up customer records, updating order status, managing content. BI platforms are for analytical questions: what are our sales trends, which products perform best, how is churn changing over time. Many teams use both: an admin panel for day-to-day operations, and a BI platform for strategic analysis.
#### Can I migrate from Basedash to Flashboard?
If you're using Basedash primarily for PostgreSQL CRUD operations, you can connect Flashboard to the same database. Flashboard doesn't require migration since it reads from your existing schema. However, dashboards, charts, and queries built in Basedash won't transfer since Flashboard doesn't offer those features.
#### Can I migrate from Flashboard to Basedash?
Yes. Since Flashboard doesn't modify your database schema, you can connect Basedash to the same database at any time. If your needs grow to require multi-source analytics or AI-powered queries, Basedash can take over. Note that Basedash doesn't have CMS features, so content editing workflows would need a different solution.
#### Which is better for non-technical team members?
Both tools are designed for non-technical users, but for different purposes. Flashboard provides a simple interface for viewing and editing database records without SQL. Basedash lets users ask questions in natural language and generates SQL automatically. If your team needs to manage individual records, Flashboard is more focused. If they need to explore data and build reports, Basedash's AI features help with that.
### Still not sure?
If you need an admin panel for managing data in a PostgreSQL database, [try Flashboard for free](https://www.getflashboard.com/auth). If you need business intelligence across multiple data sources with AI-powered queries, [explore Basedash](https://www.basedash.com). Both offer ways to evaluate before committing.
---
# Flashboard vs Avo
Flashboard and Avo are both tools for managing database content, but they take fundamentally different approaches. Flashboard is a cloud-hosted admin panel you connect to your PostgreSQL database — no coding required. Avo is a Ruby on Rails framework (a gem) that generates admin interfaces within your existing Rails application — requiring Ruby knowledge and an existing Rails codebase. This comparison documents the trade-offs between a hosted service and an embedded framework to help you choose the right approach for your situation.
### Quick comparison
| Aspect | Flashboard | Avo |
|--------|------------|-----|
| Type | Cloud SaaS | Rails gem/framework |
| Tech requirements | None (browser-based) | Ruby on Rails application |
| Deployment | Cloud-hosted | Self-hosted in your Rails app |
| Database support | PostgreSQL only | Any Rails-supported database |
| Setup time | Under 2 minutes | Hours to weeks (code-driven) |
| Rich text editing | Yes (Notion-like HTML editor) | Yes (Trix, TipTap, Markdown, EasyMDE) |
| File uploads | Yes (S3-compatible storage) | Yes (ActiveStorage integration) |
| Dashboards/Charts | No | Yes (Chartkick integration) |
| Authorization | Built-in teams/roles | Pundit policies (code-driven) |
| Customization | No-code UI configuration | Full Ruby code access |
| Pricing model | Per team (unlimited seats on higher tiers) | Per application license |
### What Flashboard does well
**Zero-code setup.** Connect your PostgreSQL database in your browser and get a complete admin panel in under 2 minutes. No Ruby, no Rails, no terminal commands, no codebase to maintain. Avo requires an existing Rails application, Ruby knowledge, and writing code to configure resources. Flashboard removes those prerequisites entirely.
**Works without an existing application.** Flashboard connects directly to your database. You don't need a web application at all — just a PostgreSQL database. Avo is a framework that runs inside a Rails application. If you don't have a Rails app, you can't use Avo.
**No infrastructure to manage.** No servers to provision, no deployments to handle, no version upgrades to apply. Flashboard handles all operational overhead. With Avo, your admin panel lives in your Rails app, so you manage its infrastructure alongside your application.
**End-to-end credential encryption.** Your database credentials are encrypted with a key only you own. Even Flashboard's team cannot access them. Avo approaches security differently — since it runs inside your own infrastructure, your credentials never leave your servers.
**Non-technical team members can manage panels.** The entire setup and configuration happens through a web interface. Non-developers can create panels, configure tables, and invite team members. Avo's configuration requires writing Ruby code, so developers must be involved in any setup or changes.
**PostgreSQL specialization.** Flashboard is built specifically for PostgreSQL. It handles foreign key relationships, JSON columns, and array types natively. Avo works with any Rails-supported database but doesn't have database-specific optimizations.
**Predictable team pricing.** Higher tiers include unlimited seats at a flat monthly rate. Avo charges per application license, which can be more economical for single-app scenarios but adds up if you have multiple projects.
### What Avo does well
**Deep Rails integration.** Avo works directly with your existing ActiveRecord models, validations, associations, and callbacks. It understands your Rails application's structure and leverages it. If you've already built business logic in Rails, Avo uses it instead of requiring you to rebuild it elsewhere.
**Full code-level customization.** Every aspect of Avo can be customized in Ruby. Custom fields, custom views, custom actions, Stimulus JS integration, TailwindCSS theming. If the default behavior doesn't fit, you can change it at the code level. Flashboard offers UI-based configuration but no code-level customization.
**Dashboards and analytics.** Avo includes dashboard pages with Chartkick integration — area charts, scatter plots, line graphs, column charts, pie charts, bar charts, metric cards. If you need to visualize data alongside your admin interface, Avo supports that workflow. Flashboard focuses on CRUD operations and doesn't include charting.
**Multiple rich text editor options.** Avo offers four rich text editors: Trix (WYSIWYG), TipTap (advanced), Markdown, and EasyMDE. Each integrates with ActiveStorage for file attachments. Flashboard has one Notion-like block editor — powerful but a single choice.
**Multi-database support.** Avo works with any database Rails supports: PostgreSQL, MySQL, SQLite, and others. If you're not using PostgreSQL, or you manage multiple database types, Avo handles that. Flashboard only supports PostgreSQL.
**Self-hosted.** Your data and credentials stay on your infrastructure. For organizations with strict compliance requirements or data sovereignty rules that prevent using cloud services, Avo's self-hosted model is the only option between these two tools.
**Pundit-based authorization.** Avo uses Pundit for authorization, giving you granular, code-driven permissions at the resource, field, and association level. You can implement complex authorization logic in Ruby. Flashboard has built-in teams and roles but without the same level of programmatic control.
**Custom actions.** Execute custom operations on single records or in bulk. Avo lets you define actions in Ruby that appear as buttons in the interface. Flashboard handles standard CRUD operations but doesn't support custom bulk actions.
**Free tier includes most features.** Avo's Community tier includes roughly 70% of features, including the core CRUD interface and rich text editors. Authorization and dashboards require the Pro tier. Flashboard's free tier is limited by edit count (30/month) rather than by features.
**Internationalization.** Avo's interface supports full i18n translation. If you need an admin panel in multiple languages, Avo has that built in.
### When to choose Flashboard
- You don't have a Ruby on Rails application
- You don't want to write or maintain code for your admin panel
- Non-technical team members need to set up and manage panels
- You want zero infrastructure and operational overhead
- You need to be up and running in minutes, not hours
- You work exclusively with PostgreSQL
- You prefer managed security with end-to-end encryption and built-in 2FA
- You want predictable per-team pricing with unlimited seats
### When to choose Avo
- You already have a Ruby on Rails application
- You want deep integration with existing models, validations, and associations
- You need dashboards with charts and analytics
- You require code-level customization beyond UI configuration
- Self-hosting is required for compliance or data sovereignty
- You use MySQL, SQLite, or other Rails-supported databases
- You want multiple rich text editor options
- You need custom actions for bulk operations
- You want Pundit-based authorization for complex permission logic
- You need multilingual support (i18n)
- You prefer per-app licensing over per-team pricing
### Frequently asked questions
#### Are Flashboard and Avo for the same audience?
Partially. Both tools help teams manage database content without building admin interfaces from scratch. However, they target different technical contexts. Avo is for Rails developers who want to add admin capabilities to an existing Rails application. Flashboard is for anyone with a PostgreSQL database — no Rails required, no coding required. If you're not using Rails, Avo isn't an option. If you are using Rails and want code-level integration, Avo offers that where Flashboard doesn't.
#### Can I use Avo without a Rails app?
No. Avo is a Rails engine (gem) that runs inside a Rails application. It depends on ActiveRecord, Rails routing, and the Rails asset pipeline. If you don't have a Rails app, you cannot use Avo. You would need to create a Rails application first, even if it only exists to run Avo.
#### Can I use Flashboard with my Rails app?
Yes. Flashboard connects to your PostgreSQL database regardless of what application uses it. If your Rails app uses PostgreSQL, you can connect Flashboard to the same database. Flashboard won't have access to your Rails models or validations — it works directly with the database schema — but it will let you manage the data. Teams can use both: Avo for developer-facing admin with full Rails integration, Flashboard for non-technical team members who need simpler data access.
#### Which has better rich text editing?
Both have capable rich text editing, but with different approaches. Flashboard offers a Notion-like block editor where you add content blocks (paragraphs, headings, lists, images) in a structured format. Avo offers four different editors — Trix, TipTap, Markdown, and EasyMDE — each with different strengths. Trix is simple WYSIWYG. TipTap is more advanced with extensibility. Markdown and EasyMDE are for teams that prefer writing in Markdown. Choose based on whether you want one polished editor (Flashboard) or multiple options to match your team's preferences (Avo).
#### Which is better for dashboards and analytics?
Avo. It includes dedicated dashboard pages with Chartkick integration for various chart types: area, scatter, line, column, pie, and bar charts, plus metric cards. You can build data visualizations alongside your admin interface. Flashboard focuses on CRUD operations and content management — it doesn't have charting or dashboard features.
#### Which is more customizable?
Avo, if you're comfortable with Ruby. You can customize fields, views, actions, styles, and behavior at the code level. You can eject views and modify them directly. You can create completely custom fields. Flashboard is configurable through its UI but doesn't offer code-level customization. If you need something Flashboard doesn't support, you can't add it yourself.
#### Which is better for non-technical users?
Flashboard. Everything happens through a web interface — connecting databases, configuring tables, inviting team members. No terminal, no code, no deployments. Avo's configuration requires writing Ruby code, so developers must handle setup and changes. Once configured, both tools have approachable interfaces for daily use, but Flashboard removes the technical barrier for initial setup and ongoing configuration.
#### What are the alternatives to both?
For Rails-specific admin panels similar to Avo: Administrate, ActiveAdmin, and RailsAdmin are open-source alternatives with different design philosophies. For cloud-hosted admin panels similar to Flashboard: Forest Admin, Basedash, Retool, and JetAdmin offer database-connected interfaces with varying feature sets and pricing models. The right choice depends on whether you want a Rails-integrated solution, a standalone cloud service, or something in between.
### Still not sure?
If you want a PostgreSQL admin panel without any coding or infrastructure work, [try Flashboard for free](https://www.getflashboard.com/auth). If you have a Rails application and want code-level integration with dashboards and custom actions, [explore Avo](https://avohq.io). Both offer free tiers, so you can evaluate each without commitment.
---
# Flashboard vs Kottster
Flashboard and Kottster are both admin panels designed for managing database records without building custom interfaces from scratch. They're direct competitors solving the same problem: giving teams a way to view and edit data without writing SQL or building admin UIs manually. Both generate interfaces based on your database schema. The main differences are in how you set them up and where they run. Flashboard is a zero-code cloud service where you connect your database and get a full admin panel instantly. Kottster is a self-hosted app that requires CLI commands, Node.js, and maintaining a codebase. This page documents the differences and trade-offs to help you choose.
### Quick comparison
| Aspect | Flashboard | Kottster |
|--------|------------|----------|
| Type | PostgreSQL admin panel + CMS | Multi-database admin panel |
| Database support | PostgreSQL only | PostgreSQL, MySQL, MariaDB, MSSQL, SQLite |
| Deployment | Cloud only | Self-hosted only |
| Open source | No | Yes (Apache 2.0) |
| Initial setup | Connect database → full admin panel | `npx @kottster/cli new` → add pages one by one |
| Requires coding | No | Yes (CLI commands, Node.js v20+, codebase) |
| Page generation | All tables auto-generated on connect | Add each page manually, then auto-generates |
| CMS features | Notion-like rich text editor, file uploads | None |
| Dashboard pages | None | Charts, metrics, custom React pages |
| Custom code | None | Full source code access (Remix/React) |
| Authentication | Built-in 2FA | Built-in IdP, SSO (paid tier) |
| Credential security | End-to-end encryption (user-owned key) | Self-hosted (you control infrastructure) |
| Pricing model | Per team (unlimited seats on higher tiers) | Free open-source + paid features |
### What Flashboard does well
**True zero-code setup.** No CLI, no Node.js, no codebase to maintain. Connect your database in your browser and get a complete admin panel with all tables in under 2 minutes. Non-technical team members can set it up without developer help. Kottster requires running terminal commands, installing Node.js v20+, and deploying to your own infrastructure.
**Full admin panel on connect.** Flashboard generates interfaces for all your tables automatically when you connect your database. With Kottster, you click "Add Page" for each table you want to manage. This gives Kottster users more control over which tables appear, but means more manual work to get started.
**CMS built in.** Write and edit rich text content with a Notion-like block editor. Upload images and files directly to your S3-compatible storage. The content is stored as HTML in your database columns, ready to render in your application. Kottster focuses on data management and doesn't include content editing features.
**No infrastructure to manage.** No servers to provision, no deployments to handle, no version upgrades to apply, no security patches to install. Flashboard handles all of that. With Kottster, you own and operate the infrastructure. That gives you control, but it also means more operational work.
**End-to-end credential encryption.** Your database credentials are encrypted with a key only you own. Even Flashboard's team cannot access them. Kottster approaches this differently by being self-hosted, so your credentials never leave your infrastructure in the first place. Both are valid security models with different trade-offs.
**Two-factor authentication.** 2FA is built into Flashboard and can be enforced for your entire team. Kottster relies on its built-in identity provider, with SSO available on paid tiers.
**PostgreSQL specialization.** Flashboard is built specifically for PostgreSQL. It handles foreign key relationships, JSON columns, and array types natively. Instead of being a generic tool for many databases, it goes deep on PostgreSQL features.
### What Kottster does well
**Self-hosted.** Your data and credentials stay on your infrastructure. For organizations with strict data sovereignty requirements, compliance rules that prevent using cloud services, or environments where data cannot leave internal networks, Kottster's self-hosting model is the only option between these two tools.
**Multi-database support.** Works with PostgreSQL, MySQL, MariaDB, Microsoft SQL Server, and SQLite. If you manage multiple database types and want one admin panel for all of them, or if you use something other than PostgreSQL, Kottster handles that. Flashboard only supports PostgreSQL.
**Dashboard and analytics pages.** Build custom dashboards with charts, metrics, and KPIs. Kottster can create reporting interfaces, not just CRUD tables. Need to show revenue trends, user growth, or operational metrics? Kottster has dedicated dashboard pages for that. Flashboard focuses on data management and CMS features, not analytics.
**Full source code access.** Each page in Kottster lives at `app/routes//index.jsx`. Need something custom? Edit the React code directly. Built on Remix (Node.js + React), it's a real framework you can extend in any direction. Flashboard is a closed service with no code-level customization.
**Open source (Apache 2.0).** Audit the source code, contribute fixes, understand exactly how your admin panel works. Fork it if needed. For teams that require visibility into their tools or need to make modifications, this transparency matters. Flashboard is a closed-source cloud service.
**Free tier with unlimited users.** Kottster's free Community tier has no user limits. Add your entire team without per-seat costs. Flashboard's free tier includes 1 seat, with unlimited seats available on higher-tier plans.
**Custom React pages.** Beyond auto-generated table pages, build completely custom interfaces with React. Forms, wizards, complex workflows, multi-step processes. If you can code it in React, you can add it to Kottster. Flashboard's UI is generated from your schema, not customizable at the code level.
**Granular page control.** Add only the pages you need. Start with just the tables your team uses, then add more as needed. Flashboard takes the opposite approach: it generates interfaces for all tables automatically, then you remove the ones you don't need. Both workflows get you to the same place, just different starting points.
### When to choose Flashboard
- You want an admin panel working in minutes, not hours
- You don't want to run CLI commands, manage a codebase, or deploy infrastructure
- You need CMS capabilities alongside database management
- You work exclusively with PostgreSQL
- Non-technical team members need to set up or manage the panel
- You want predictable pricing for growing teams (unlimited seats on higher tiers)
- End-to-end credential encryption is a requirement
- You need built-in 2FA that can be enforced for your team
### When to choose Kottster
- Self-hosting is required (data cannot leave your infrastructure)
- You work with MySQL, MariaDB, MSSQL, SQLite, or multiple database types
- You need dashboard pages with charts and metrics
- You want full control over the UI with custom React code
- You prefer open-source solutions you can audit and modify
- Your team is comfortable with Node.js and maintaining a codebase
- You prefer adding pages incrementally rather than removing unused ones
- You need SSO/SAML integration (available on Kottster's paid tier)
### Frequently asked questions
#### Are Flashboard and Kottster the same type of tool?
Yes, they're direct competitors solving the same problem. Both are admin panels that auto-generate interfaces from your database schema. Both let you view, create, edit, and delete records without writing SQL. The main differences are in deployment (cloud vs self-hosted), setup requirements (zero-code vs CLI/codebase), and feature focus (CMS vs dashboards). If you're evaluating database admin panels, both belong on your shortlist.
#### Which is cheaper for my team?
It depends on team size and what features you need. Kottster's free Community tier includes unlimited users, so you can add your whole team at no cost. Flashboard's free tier includes 1 seat, but higher tiers include unlimited seats at a flat monthly rate. If you need Kottster's paid features like SSO, audit logging, or data change history, those add to the cost. For a small team that doesn't need CMS features, Kottster's free tier may be cheaper. For growing teams that need CMS and don't want per-user pricing, Flashboard's unlimited seats can be more predictable.
#### Can I migrate from Kottster to Flashboard?
If your data is in PostgreSQL, yes. Connect Flashboard to the same database. Flashboard reads your existing schema without requiring migrations. Custom React pages and dashboard code you built in Kottster won't transfer since Flashboard doesn't have those features. If you're using Kottster with MySQL, MariaDB, MSSQL, or SQLite, Flashboard won't work since it only supports PostgreSQL.
#### Can I migrate from Flashboard to Kottster?
Yes. Kottster supports PostgreSQL, so you can connect it to the same database. Rich text content created with Flashboard's CMS is stored as HTML in your database columns. It will display as text in Kottster since it doesn't have CMS features, but the data is preserved. You'll need to recreate your pages manually in Kottster since it doesn't auto-generate all tables on connect.
#### Which is easier to set up?
Different definitions of "easy" for different teams. Flashboard is faster for non-technical users. Connect your database in your browser, and you have a working admin panel in under 2 minutes. No terminal commands, no installing dependencies, no deployment. Kottster requires Node.js v20 or higher, running `npx @kottster/cli new` to scaffold a project, `npm run dev` to start development, and eventually deploying to your own infrastructure (Vercel, your own servers, etc.). If your team is comfortable with Node.js and terminal commands, Kottster's setup is straightforward. If not, Flashboard removes that barrier entirely.
#### Do I need self-hosting?
Most teams don't. Self-hosting adds operational complexity: you're responsible for updates, backups, security patches, and uptime. However, some organizations have compliance requirements that prevent using cloud services, or strict data sovereignty rules that require data to stay on-premises. If that's your situation, Kottster's self-hosting is the only option between these two tools. If you don't have those requirements, cloud hosting typically reduces operational burden.
#### Which is better for dashboards and analytics?
Kottster. It has dedicated dashboard pages where you can build charts, display metrics, and create KPI visualizations. If you need to show revenue trends, user growth, or operational dashboards alongside your data management interface, Kottster supports that workflow. Flashboard focuses on CRUD operations and CMS content editing. It doesn't have chart or dashboard features.
#### Which is better for security?
Both tools offer strong security models, just different approaches. Flashboard uses end-to-end encryption for database credentials (encrypted with a key only you own) and built-in 2FA that can be enforced team-wide. Kottster sidesteps the credential security question entirely by being self-hosted: your credentials never leave your infrastructure. Both include authentication systems and access controls. Choose based on whether you prefer cloud-managed security or infrastructure you control.
#### Which is better for non-technical team members?
Flashboard. The entire experience happens in a web browser. No CLI, no terminal commands, no codebase to maintain, no deployments to manage. Non-technical team members can connect a database, use the admin panel, and even set up new panels without developer involvement. Kottster requires someone comfortable with Node.js and terminal commands for initial setup and ongoing maintenance. Once set up, the day-to-day usage of both tools is similar, but Flashboard's setup process has fewer technical prerequisites.
#### What are the best alternatives to both?
For full-featured internal tool builders: Retool, Appsmith, and Budibase let you build custom applications with drag-and-drop interfaces, not just database admin panels. For admin panels focused on existing databases: Forest Admin, Basedash, JetAdmin, and Rocketadmin are direct competitors. The right choice depends on whether you need a simple admin panel (Flashboard, Kottster, Rocketadmin) or a platform for building custom internal applications (Retool, Appsmith).
### Still not sure?
If you want a PostgreSQL admin panel with CMS features and zero setup complexity, [try Flashboard for free](https://www.getflashboard.com/auth). If you need self-hosting, multi-database support, or custom dashboards with full code access, [explore Kottster](https://kottster.app). Both offer free tiers, so you can evaluate each without commitment.
---
# Flashboard vs Rocketadmin
Flashboard and Rocketadmin are both no-code admin panels designed for managing database records without writing SQL. They're direct competitors solving the same problem: giving teams a way to view and edit database data without writing code. The main differences are in their approach — Rocketadmin is open-source and supports multiple databases, while Flashboard specializes in PostgreSQL and includes CMS capabilities. This page documents the differences and trade-offs to help you choose.
### Quick comparison
| Aspect | Flashboard | Rocketadmin |
|--------|------------|-------------|
| Type | PostgreSQL admin panel + CMS | Multi-database admin panel |
| Database support | PostgreSQL only | MySQL, PostgreSQL, MSSQL, Oracle, MongoDB |
| Deployment | Cloud only | Cloud + self-hosted (Docker/Helm) |
| Open source | No | Yes |
| Setup time | Under 2 minutes | Under 5 minutes |
| CMS features | Notion-like rich text editor, file uploads | None |
| Custom actions | No | Yes (webhook-based) |
| Automation integrations | None | Zapier, OpenAI API |
| Storage integrations | S3-compatible (AWS, Supabase, etc.) | None |
| White-label | No | Yes |
| 2FA | Yes | No |
| IP whitelisting | Yes (application-level) | Yes (broad database-level permissions required) |
| Credential security | End-to-end encryption | Client encryption |
| Pricing model | Per team (unlimited seats on higher tiers) | Per user |
### What Flashboard does well
**CMS built in.** Write and edit rich text content with a Notion-like block editor. Upload images and files directly. The content is stored as HTML in your database columns, ready to render in your application. Rocketadmin focuses on data management and doesn't include content editing features.
**PostgreSQL specialization.** Flashboard is built specifically for PostgreSQL. It handles foreign key relationships, JSON columns, and array types natively. Instead of being a generic tool for many databases, it goes deep on PostgreSQL features.
**Unlimited seats on higher tiers.** Flashboard's Team and Pro plans include unlimited seats at a flat monthly rate. Rocketadmin charges per user, which adds up as your team grows. For teams larger than 10 people, Flashboard's pricing can be significantly more predictable.
**End-to-end credential encryption.** Your database credentials are encrypted with a key only you own. Even Flashboard's team cannot access them. Rocketadmin offers client encryption but doesn't use the same end-to-end model.
**2FA and application-level IP whitelisting.** Flashboard includes two-factor authentication and IP-based access control built into the application. You can restrict which IP addresses can access your admin panel without modifying your database configuration. Flashboard works seamlessly with provider-level trusted sources (like DigitalOcean, Supabase, or Neon). Rocketadmin requires adding their server IP to your pg_hba.conf file with a rule like ` all md5`, which grants any user from their IP address authentication access to your database. This is an additional configuration step that may not be possible on some managed database providers, and also a security concern.
**Instant setup.** Connect your PostgreSQL database and get a working admin panel in under 2 minutes. No configuration files, no designing interfaces. Flashboard reads your schema and generates the UI automatically.
### What Rocketadmin does well
**Open source.** Rocketadmin's source code is available on GitHub. For organizations that need to audit their tools, contribute fixes, or understand exactly how their admin panel works, this transparency is valuable. Flashboard is a closed-source cloud service.
**Self-hosting option.** Rocketadmin can be deployed on your own infrastructure using Docker containers or Helm charts. For organizations with strict data sovereignty requirements or those who cannot use cloud services, this is a significant advantage. Flashboard is cloud-only.
**Multi-database support.** Rocketadmin works with MySQL, PostgreSQL, MSSQL, Oracle, and MongoDB. If you manage multiple database types and want a single tool for all of them, Rocketadmin handles that. Flashboard only supports PostgreSQL.
**Custom actions.** Rocketadmin lets you create webhook-based operations that trigger external services. Ban a user, send an email, generate a PDF report, or call any API endpoint. These custom actions appear as buttons in the interface. Flashboard doesn't currently offer custom actions.
**White-label branding.** Customize Rocketadmin with your company logo, business name, and brand colors. For agencies or companies embedding the admin panel into their product, this helps maintain brand consistency. Flashboard doesn't offer white-label customization.
**Zapier and AI integration.** Connect Rocketadmin to thousands of apps through Zapier. Use OpenAI integration for AI-powered data analysis. Flashboard doesn't currently have integrations with this kind of services.
**Lower per-user cost for small teams.** Rocketadmin uses per-user pricing with a free tier for small teams. For teams of just a few people, this can be more economical than Flashboard's fixed monthly plans.
### When to choose Flashboard
- You need CMS capabilities alongside database management
- You work exclusively with PostgreSQL and want deep PostgreSQL features
- You have a growing team and want predictable pricing without per-seat costs
- You want the fastest possible setup with minimal configuration
- End-to-end credential encryption is a requirement
- You need two-factor authentication (2FA)
- You need IP whitelisting without broad database configuration
### When to choose Rocketadmin
- You need self-hosting (data cannot leave your infrastructure)
- You work with multiple database types and want one tool for all of them
- You need custom webhook-based actions for operations workflows
- You want white-label branding for client-facing deployments
- You're a small team (under 10) where per-user pricing is cheaper
- You prefer open-source solutions you can audit and modify
- You need Zapier integration or AI features
### Frequently asked questions
#### Are Flashboard and Rocketadmin the same type of tool?
Yes, both are no-code admin panels designed for managing database records without writing SQL. They serve similar use cases: giving non-technical team members access to view and edit data, building internal tools for customer support, and managing production databases safely. The main differences are in database support, deployment options, and additional features like CMS or custom actions.
#### Which is cheaper for my team?
It depends on team size. Rocketadmin charges per user with a free tier for small teams. Flashboard charges per team with unlimited seats on higher tiers. For small teams, Rocketadmin's per-user pricing is often cheaper. For larger teams, Flashboard's unlimited seats provide more predictable costs. Check each product's pricing page for current rates.
#### Can I migrate from Rocketadmin to Flashboard?
If your data is in PostgreSQL, yes. Connect Flashboard to the same database. Flashboard reads your existing schema without requiring migrations. Custom actions and Zapier workflows built in Rocketadmin won't transfer since Flashboard doesn't have those features. If you're using Rocketadmin with MySQL, Oracle, MSSQL, or MongoDB, Flashboard won't work since it only supports PostgreSQL.
#### Can I migrate from Flashboard to Rocketadmin?
Yes. Since Flashboard doesn't modify your database schema, you can connect Rocketadmin to the same PostgreSQL database. Rich text content created in Flashboard is stored as HTML, which will display as text in Rocketadmin since it doesn't have CMS features. Your saved filters and UI customizations won't transfer.
#### Which is better for customer support teams?
Both tools work well for customer support and both include activity logs for tracking changes. The main difference is that Rocketadmin has custom actions for operations like banning users or triggering emails, while Flashboard has CMS features for content management. If you need custom operational workflows, Rocketadmin may be more suitable. If you need content management alongside data management, Flashboard is designed for that.
#### Do I need self-hosting?
Most teams don't. Self-hosting adds operational complexity: you're responsible for updates, backups, and security patches. However, some organizations have compliance requirements that prevent using cloud services, or strict data sovereignty rules that require data to stay on-premises. If that's your situation, Rocketadmin's Docker/Helm deployment is the only option between these two tools.
#### Which is better for agencies building client projects?
Both can work. Rocketadmin's white-label feature lets you brand the admin panel with your client's logo and colors. Flashboard's CMS features are useful if clients need to edit content. If you're building for multiple clients with different database types, Rocketadmin's multi-database support helps. If all your clients use PostgreSQL and need content management, Flashboard may be more focused on that workflow.
#### What are the best alternatives to both?
For full-featured internal tool builders: Retool, Appsmith, and Budibase. For admin panels focused on existing databases: Forest Admin, Basedash, and JetAdmin. The right choice depends on whether you need a simple admin panel (Flashboard, Rocketadmin) or a platform for building custom internal applications (Retool, Appsmith).
### Still not sure?
If you need a PostgreSQL admin panel with CMS features, [try Flashboard for free](https://www.getflashboard.com/auth). If you need multi-database support or self-hosting, [explore Rocketadmin](https://rocketadmin.com). Both offer free tiers, so you can evaluate each without commitment.