Chartbrew tackles a common challenge developers and teams face: building and managing data dashboards that pull from various data sources without the overhead of complex BI tools or rigid SaaS platforms.
What chartbrew does and its architecture
Chartbrew is an open-source data visualization and dashboard platform built primarily with JavaScript and NodeJS. It provides an API backend that handles data querying and processing, and a frontend client that renders charts and dashboards for end users.
Under the hood, the backend supports connections to relational databases like MySQL (5+) and PostgreSQL (12.5+), which are the primary data sources for creating charts. Redis (v6+) is also required, likely for caching, session management, or pub/sub functionality to improve performance and UX responsiveness.
The repo supports running directly on NodeJS or containerized with Docker. The Docker setup is especially useful for simplifying deployment, packaging all dependencies and environment configuration.
The architecture separates concerns cleanly: the API server runs on NodeJS exposing endpoints for chart and dashboard management, while the frontend client (likely a modern JavaScript SPA) consumes these APIs to deliver an interactive user experience.
What stands out technically in chartbrew
Chartbrew isn’t just a visualization tool; it’s a data pipeline from source to dashboard. The backend code handles data querying, transformations, and probably caching with Redis to optimize repeated queries.
The codebase is reasonably mature given the community interest (3,900+ stars). It uses environment variables extensively for configuration, including database credentials and a 32-byte AES encryption key for securing sensitive data. This shows attention to security and deployability.
The tradeoff here is setup complexity: you need a compatible database, Redis, and correctly configured environment. But this is typical for self-hosted BI tools aiming to give you control over data.
From an API perspective, the backend likely exposes RESTful endpoints, with the frontend consuming these to provide live updates and dashboard management. The use of Redis hints at potential real-time features or caching layers.
The Docker image is built and released alongside versions, streamlining continuous delivery and making it easier for users to deploy without manual installs.
Quick start with docker
The README provides a clear set of commands to get started with Docker:
# Generate a 32-byte AES encryption key
node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"
# Pull the latest Chartbrew Docker image
docker pull razvanilin/chartbrew
# Run the Chartbrew container with environment variables
docker run -p 4019:4019 -p 4018:4018 \
-e CB_ENCRYPTION_KEY=your_32_bytes_key \
-e CB_API_HOST=0.0.0.0 \
-e CB_API_PORT=4019 \
-e CB_DB_HOST=host.docker.internal \
-e CB_DB_PORT=3306 \
-e CB_DB_NAME=chartbrew \
-e CB_DB_USERNAME=root \
-e CB_DB_PASSWORD=password \
-e CB_REDIS_HOST=host.docker.internal \
-e CB_REDIS_PORT=6379 \
-e CB_REDIS_PASSWORD=password \
-e VITE_APP_CLIENT_HOST=http://localhost:4018 \
-e VITE_APP_CLIENT_PORT=4018 \
-e VITE_APP_API_HOST=http://localhost:4019 \
razvanilin/chartbrew
This setup assumes you have MySQL and Redis running locally or accessible from Docker. The environment variables point Chartbrew to those resources and configure the frontend ports.
This direct Docker approach reduces friction for developers who want to try the tool quickly or deploy it in a containerized environment.
Verdict: who should consider chartbrew
Chartbrew is a practical self-hosted dashboard solution for teams or developers who want control over their data visualization stack without relying on SaaS. Its NodeJS backend with MySQL/PostgreSQL and Redis integration offers flexibility and performance.
The tradeoff is in setup complexity: you need to manage your database, Redis, and environment configuration carefully to get it running properly. For teams comfortable with Docker and backend setups, it’s a solid choice.
If you need a quick SaaS alternative, Chartbrew won’t compete there. But if you want to own your data pipeline, customize dashboards deeply, and integrate with existing SQL databases, it’s worth a look.
The codebase is active, and the Docker deployment shows clear attention to DX and real-world usability.
Overall, Chartbrew is a well-structured open-source project that balances flexibility, performance, and usability for self-hosted data visualization needs.
Related Articles
- Vaultwarden: a resource-efficient Rust implementation of the Bitwarden server API — Vaultwarden is a lightweight, Rust-based server compatible with the Bitwarden API, optimized for self-hosting with low r
- Ferret v2: A declarative Go engine for web data extraction with a new API architecture — Ferret v2 is a Go-based declarative system for web scraping that introduces a native Go API and a compatibility layer to
- Supabase: composable open-source backend-as-a-service built around Postgres — Supabase combines specialized open-source tools around Postgres to offer a Firebase-like backend platform. Its modular a
→ GitHub Repo: chartbrew/chartbrew ⭐ 3,904 · JavaScript