Notebooks and dashboards with Python, SQL, scheduling, native visualizations, code generation, and more.

Slack | Website | Docs | Blog | Issues | Try the cloud version »

We can help you deploy Briefer for free. Book a time here.

Here's a brief demo (no pun intended) of Briefer. It may take a few seconds to load.

Briefer is like Notion for code notebooks and dashboards. It gives technical users all the flexibility they need to publish dashboards, analyze data, create reports, and build data apps. At the same time, Briefer makes it easy for non-technical users to view and interact with data.

In Briefer, you can:

• 📚📊 Create notebooks and dashboards using Markdown, Python, SQL, and native visualizations.
• 🤳 Build interactive data apps using inputs, dropdowns, and date pickers.
• 🤖 Generate code and queries using an AI that understands your database schema and your notebook's context.
• 🕰️ Schedule notebooks and dashboards to run and update periodically.
• ⚙️ Create and test ad-hoc pipelines using writebacks.

In addition to all that, Briefer is also multiplayer, meaning two or more people can work on the same notebook or dashboard at the same time and see each other's changes in real-time.

The recommended way to run Briefer locally is to install it using pip and run it using the briefer command. Please note that Briefer requires Docker to run, so make sure you have it installed before running the commands below.

# Install Briefer
pip install briefer

# Run Briefer and access it on http://localhost:3000
briefer

If you run Briefer using pip, our initialization scripts will take care of downloading our docker image, setting up volumes to store Briefer's data, and starting the application.

Alternatively, you can also run Briefer using Docker directly:

# Run Briefer using Docker
docker run -d \
  -p 3000:3000 \
  -v briefer_psql_data:/var/lib/postgresql/data \
  -v briefer_jupyter_data:/home/jupyteruser \
  -v briefer_briefer_data:/home/briefer \
  briefercloud/briefer

When running on Windows' PowerShell, it might be necessary to add an extra ` to the end of each line instead of the \, like this:

# Run Briefer using Docker
docker run -d `
  -p 3000:3000 `
  -v briefer_psql_data:/var/lib/postgresql/data `
  -v briefer_jupyter_data:/home/jupyteruser `
  -v briefer_briefer_data:/home/briefer `
  briefercloud/briefer

These volumes are for Briefer to store its data, including its pages, dashboards, schedules, and users. If you want to remove Briefer's data, you can remove these volumes.

For more information on how to deploy Briefer in production, please refer to our deployment guide.

If you want to contribute to Briefer, please read our contributing guide which explains how run Briefer in development mode.

Briefer is a collaborative web application. Each instance of Briefer can have multiple users who share a workspace containing multiple pages.

Ideally, you'll deploy Briefer somewhere where your team can access it, like a server or a cloud provider. Once you have Briefer running, you can access it on your browser and start creating pages.

To fetch external data in Briefer, you can connect it to your databases, like PostgreSQL, BigQuery, Redshift, Athena, or MySQL. You can also upload any types of files and work with them as if they were on disk.

You can view each Briefer page as a notebook or a dashboard.

In the notebook mode, you can write SQL to fetch data, Python to manipulate or visualize it, and Markdown to document your analysis. You can also use native visualizations to create charts and tables without having to write code.

Then, in the dashboard mode, you can create dashboards by dragging and dropping the elements from your notebook. You can also add inputs, dropdowns, and date pickers to create interactive filters or data apps.

After you're done creating your notebook or dashboard, you can publish your changes so that other users can see them.

Once a page is published, you'll be able to schedule it to run periodically so that your dashboards and notebooks are always up-to-date.

There are two types of tools people usually compare us against. The first type is traditional BI tools like Tableau, Looker, or Power BI. The second type is notebooks like Jupyter, or Google Colab, whose results often get screenshoted and pasted in Notion or Confluence.

Here's how Briefer compares to each of them.

Briefer is better than traditional BI tools because it's faster and more flexible, thanks to Python.

Traditional BI tools often require you to write complex SQL queries to fetch data, and then limit you to a set of pre-defined visualizations. Most of the time, the only way to manipulate these visualizations is by clicking around the UI, which can be slow and error-prone.

Briefer supports SQL and no-code visualizations too, but it also allows you to write Python code to manipulate data and create custom visualizations.

This means you can do things like:

• Fetch data from multiple sources and join them together without having to create a data pipeline beforehand
• Hit APIs to gather data or enrich your own
• Use machine learning to include predictive analytics in your dashboards

Additionally, many data and engineering teams end up splitting their work between a BI tool and a jupyter notebook. That makes it hard to keep track of what's happening and to collaborate effectively. In Briefer, you can do everything in one place.

We love notebooks, but there are three main problems with them:

1. They're difficult to share and maintain, especially with non-technical people.
2. They require local credentials and lots of boilerplate code to fetch data from databases or APIs.
3. Their UX is far from ideal: you don't have integrated scheduling or code generation, for example.

The main problem with notebooks is that they're difficult to share and maintain, especially with non-technical people. Therefore, data scientists, analysts, and engineers often struggle to share their work and get the visibility they deserve within their organizations.

Usually, the only way to share a notebook is to take screenshots and paste them in Notion or Confluence. That workaround is not ideal because it's time-consuming, and the information quickly becomes outdated, especially when you need to update it.

Briefer solves this problem because every Briefer notebook is stored in a single place that everyone in your organization can access. Briefer's interface is also much more user-friendly than Jupyter, which makes it easier for non-technical people to view and interact with data.

In addition to Briefer's friendly interface, you can also choose which blocks of your notebook you want to publish, so you can keep your data jiu-jitsu private while sharing the relevant insights and visualizations with your team.

Currently, people who want to gather data in notebooks have to keep credentials in their machines, which is not secure. They also have to write a lot of boilerplate code to run simple queries. Sometimes, people create whole libraries to handle queries.

In Briefer, you can run SQL queries against connected data sources directly in your notebook. Then, Briefer will automatically turn your query into a data frame and store it in a variable that you can use in your Python blocks.

If you need to fetch data from an API, you can use Briefer's environment variables to store your credentials securely in a single place instead of handing them out to everyone in your organization.

Finally, in case you want to use files, you can upload them to Briefer and read them in Python or query them using SQL thanks to our DuckDB integration.

Besides our improved interface, Briefer integrates several UX improvements directly into your notebooks.

In Briefer, you can schedule your notebooks to run periodically. That way, you don't have to turn them into an ad-hoc script that you schedule with cron or Airflow. Each of these scheduled runs generates a snapshot that you can use to compare changes over time.

Finally, Briefer can generate code for you. If you're not sure how to write a query or a Python block, you can ask Briefer to generate it for you. Briefer will look at your database schema and your notebook's context to suggest changes. If you run into an error, Briefer can also suggest fixes.

Briefer is an application with three main components: the web, the api, and an optional ai service. These three components require a PostgreSQL database to store their data, and a jupyter server to run your code.

The web is the main interface of Briefer. It's where you create and edit your notebooks and dashboards. The web is a Next.js application that communicates with the api to fetch and save data.

Besides responding to web's requests, the api is also responsible for running your notebooks and dashboards, and fetching data from the data sources you add to Briefer. The api is a Node.js application.

Finally, the optional ai service is a Python service that generates code for the AI features, like "Edit with AI" and "Fix with AI". You don't necessarily need to run it, unless you're working on these features or want to use them. Please note that using the ai service requires an admin to configure an OpenAI API key under the Settings page. This service does make requests to OpenAI's API.

Briefer's open-source offering is licensed under the AGPLv3 license. This license allows you to use Briefer for free, but it requires you to open-source any changes you make to the codebase under the same license. Your notebooks and dashboards are yours, and you can do whatever you want with them.

Briefer's cloud offering is a separate piece of software that we host and maintain. It's not open-source, but it's free to use and includes additional features like email and Slack integrations, more granular permissions, and SSO.

You can read more about our licensing decisions and open-source philosophy in this blog post. To summarise, we'll aim to include all data-related features in the open-source version and save integrations and granular permissions for the cloud version.

Briefer collects anonymous telemetry that we use to improve our product. This telemetry includes only event counts and a randomly generated ID for each user. We don't collect any personal information or data from your notebooks, dashboards, queries, or prompts.

You can opt-out of telemetry by setting the environment variable DISABLE_ANONYMOUS_TELEMETRY to true. To also disable the periodic requests that Briefer makes to check for updates, you can set the environment variable DISABLE_UPDATE_CHECK to true.