
CEO & Co-founder of Visivo
Developer-Centric BI Dashboards for Modern Data Teams
Build developer-centric BI dashboards using Visivo's code-first approach, version control, and CI/CD pipelines for scalable analytics.

Developers work in code, Git and automation. According to the 2023 Stack Overflow Developer Survey, 96.5% of professional developers use Git for version control. Most BI tools ignore that workflow. A developer-centric BI dashboard is one that fits into it: defined in code, reviewed in a pull request, tested in CI. This post shows what that looks like with Visivo's YAML configuration.
Where traditional BI loses developers
After years in code editors, version control and automated tests, a developer is asked to build dashboards by clicking through a GUI, copying settings by hand, and publishing changes with no review and no tests.
A typical week:
Monday: Sarah, a full-stack developer, needs a dashboard for API performance. She opens the BI tool and spends 30 minutes working out how to connect to the database.
Tuesday: She has a basic chart. Every change means a trip through nested menus. No keyboard shortcuts, no search, no copy-paste between charts.
Wednesday: She wants the dashboard in version control, but the tool stores everything in a proprietary database. She takes screenshots and writes a doc that will be stale in a month.
Thursday: A colleague needs a similar dashboard with one difference. Sarah rebuilds it from scratch, because there is no way to generate a variation.
Friday: She deploys by clicking Publish. If it breaks, there is no rollback and no clear way to find out why.
A team that ships a software feature in hours spends days on a basic dashboard. The 2023 GitLab DevSecOps report reports that version control adoption increases team productivity by up to 40% and reduces deployment failures. Most BI tools offer neither.
What makes a dashboard developer-centric
Five properties, each borrowed from software engineering:
Code-first configuration
Everything is defined in a text format such as YAML. Developers use their own editor, with syntax highlighting, completion and linting.
Version control integration
Configuration lives in Git next to application code: branches, merges, diffs and full history.
Automated testing
Dashboard configuration is validated and tested in CI before it ships.
Modular architecture
Components compose and get reused. Common patterns become shared definitions instead of copies.
API-first design
Anything a GUI can do, a CLI or an API can do too, so it can be automated.
A dashboard becomes a software artifact rather than a static report. For the fundamentals, read our BI-as-code introduction.
How Visivo does it
Visivo is a YAML project and a CLI. The workflows developers already use map directly onto it:
Local development
Analytics development starts on your machine, like any other project:
# Initialize new analytics project
pip install visivo # Install from https://pypi.org/project/visivo/
visivo init --project-dir team-analytics --bare
cd team-analytics
# Local development workflow
vim project.visivo.yml # Edit in preferred editor
visivo serve # Run local development server
visivo test # Run tests and validation
# Version control
git add .
git commit -m "Add new performance dashboard"
git push origin feature/performance-metrics
Working in your editor
A Visivo project is plain YAML, so it opens in any editor:
# project.visivo.yml - Works with any code editor
name: Engineering Analytics
sources:
- name: app_db
type: postgresql
host: ${env.DB_HOST}
database: ${env.DB_NAME}
username: ${env.DB_USER}
password: ${env.DB_PASSWORD}
models:
- name: api_performance
source: ${ref(app_db)}
sql: |
SELECT
DATE_TRUNC('hour', timestamp) as hour,
endpoint,
AVG(response_time_ms) as avg_response_time,
COUNT(*) as request_count,
COUNT(CASE WHEN status_code >= 400 THEN 1 END) as error_count,
PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY response_time_ms) as p95_response_time
FROM api_logs
WHERE timestamp >= NOW() - INTERVAL '7 days'
GROUP BY DATE_TRUNC('hour', timestamp), endpoint
ORDER BY hour DESC, endpoint
insights:
- name: response-time-trend
props:
type: scatter
mode: lines+markers
x: ?{ ${ref(api_performance).hour} }
y: ?{ ${ref(api_performance).avg_response_time} }
name: ?{ ${ref(api_performance).endpoint} }
line:
width: 2
hovertemplate: |
<b>%{fullData.name}</b><br>
Time: %{x}<br>
Avg Response Time: %{y:.1f}ms<br>
<extra></extra>
interactions:
- split: ?{ ${ref(api_performance).endpoint} }
charts:
- name: api-performance-dashboard
insights:
- ${ref(response-time-trend)}
layout:
title:
text: "API Performance Over Time"
font:
size: 20
xaxis:
title:
text: "Time"
type: date
yaxis:
title:
text: "Response Time (ms)"
hovermode: x unified
height: 400
dashboards:
- name: Engineering Metrics
rows:
- height: large
items:
- chart: ${ref(api-performance-dashboard)}
What the editor gives you
Syntax highlighting and validation: Any modern editor highlights YAML and can validate it against the Visivo schema.
Auto-completion: The YAML Language Server suggests Visivo configuration options as you type.
Refactoring: Rename a model, Insight or chart with find-and-replace.
Code navigation: Find every use of a model, Insight or chart with your editor's project search.
Debugging: Invalid configuration produces an error with a file and line number.
Patterns for larger projects
Modular configuration
A large Visivo project splits into files the same way a large codebase does:
# Organized project structure
analytics-platform/
├── project.visivo.yml # Main project configuration
├── sources/
│ └── app_db.visivo.yml # One source, credentials from env vars
├── models/
│ ├── core/
│ │ ├── users.visivo.yml # Core user models
│ │ └── events.visivo.yml # Core event models
│ ├── marketing/
│ │ ├── campaigns.visivo.yml
│ │ └── attribution.visivo.yml
│ └── engineering/
│ ├── performance.visivo.yml
│ └── deployments.visivo.yml
├── insights/
│ ├── shared/
│ │ └── common_insights.visivo.yml
│ └── dashboards/
│ ├── executive.visivo.yml
│ └── operational.visivo.yml
├── charts/
│ ├── templates/
│ │ └── standard_layouts.visivo.yml
│ └── specific/
│ ├── revenue_charts.visivo.yml
│ └── performance_charts.visivo.yml
└── dashboards/
├── executive.visivo.yml
├── marketing.visivo.yml
└── engineering.visivo.yml
The project file composes them with includes:
# project.visivo.yml
name: Analytics Platform
includes:
# Data sources
- path: sources/
# Core data models (directories are included recursively)
- path: models/
# Visualization insights
- path: insights/
# Chart definitions
- path: charts/
# Dashboard layouts
- path: dashboards/
defaults:
source_name: app_db
Environment management
Each environment needs its own connection details. Visivo reads ${env.VAR_NAME} references on source connection fields, filled from a .env file for each environment:
# sources/app_db.visivo.yml
sources:
- name: app_db
type: postgresql
host: ${env.DB_HOST}
database: ${env.DB_NAME}
username: ${env.DB_USER}
password: ${env.DB_PASSWORD}
Switching environments is a different .env file:
# Local development (reads .env from the project root)
visivo serve
# Staging deployment
visivo --env-file .env.staging run
visivo deploy -s staging
# Production deployment
visivo --env-file .env.production run
visivo deploy -s production
Testing
A Visivo test is a Python expression that asserts on the values an Insight computes:
# tests/data_quality.visivo.yml
tests:
- name: response-time-trend-has-data
assertions:
- ">{ len( ${ref(response-time-trend).props.x} ) > 0 }"
- name: response-time-sanity-check
assertions:
- ">{ numpy.max( ${ref(response-time-trend).props.y} ) < 10000 }"
The same tests run locally and in CI:
# Run all tests locally
visivo test
# Run tests against a different default source
visivo test --source staging_db
This is real output from Visivo 2.3.0 on a copy of this project with sample data in which one endpoint has an hour of timeouts. visivo test prints a dot for each passing assertion and an F for each failing one, then the failed assertion with its actual value:
$ visivo test
Starting Visivo...
Compile completed in 0.02s imports: 0.0s, parse: 0.01s
.F
Testing complete. 2 tests run in 0 seconds.
Failures:
> project.tests[1]: >{ numpy.max( ${ref(response-time-trend).props.y} ) < 10000 } (actual: 13972.203886162228 < 10000)
visivo test exited with status 1 here, which fails the CI job that runs it.
Editor and CLI tooling
VS Code setup
Two settings files give VS Code schema validation and completion for Visivo files:
// .vscode/settings.json
{
"yaml.schemas": {
"https://docs.visivo.io/assets/visivo_schema.json": ["*.visivo.yml"]
},
"yaml.completion": true,
"yaml.validate": true,
"yaml.hover": true,
"files.associations": {
"*.visivo.yml": "yaml"
}
}
// .vscode/extensions.json - Recommended extensions
{
"recommendations": [
"redhat.vscode-yaml",
"ms-python.python",
"ms-vscode.vscode-json"
]
}
Debugging
The CLI is the debugger:
# Validate configuration; errors point to the file and line
visivo compile
# List what the project defines
visivo list models
visivo list insights
# Run only one dashboard and the objects it depends on
visivo run --dag-filter "'Engineering Metrics'+"
visivo compile also writes the SQL for each Insight to the target/ directory, so you can read the exact query Visivo will send to your database.
Starting from examples
To start from working code instead of a blank file, create a project from one of the bundled examples:
visivo init --example ev-sales --project-dir ev-sales-demo
From there, the semantic layer and includes let you reuse metrics, dimensions, and files across dashboards.
Collaboration
Code review
Because the project is YAML, an analytics change is a pull request, reviewed like any other.
A reviewer checks:
Data logic: Is the SQL correct and efficient? Performance: Will the query hurt production systems? Security: Does it expose data or allow injection? Business logic: Do the calculations match the requirement? User experience: Does the chart and dashboard design make sense?
Pair programming
Pairing works the same way it does on application code:
# Developer A runs the local server
visivo serve --port 3000
# Share port 3000 through VS Code Live Share so Developer B sees the live dashboard
# Both can edit YAML files and see changes immediately
# Use VS Code Live Share for real-time collaboration
# Multiple developers can edit Visivo files simultaneously
Documentation
Documentation lives in the same file as the definition it describes:
# models/api_performance.visivo.yml
#
# API performance metrics aggregated by hour and endpoint.
#
# Data Sources:
# - api_logs table (production application logs)
#
# Business Logic:
# - Response times are averaged per hour/endpoint combination
# - Error rate calculated as 4xx/5xx responses / total requests
# - P95 response time provides insight into worst-case performance
#
# Data Retention: 30 days of hourly aggregates
#
# Related Dashboards:
# - Engineering Metrics Dashboard
# - SRE Operations Dashboard
#
# Owner: engineering-team
models:
- name: api_performance
sql: |
SELECT
DATE_TRUNC('hour', timestamp) as hour,
endpoint,
AVG(response_time_ms) as avg_response_time,
COUNT(*) as request_count,
COUNT(CASE WHEN status_code >= 400 THEN 1 END) as error_count,
PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY response_time_ms) as p95_response_time
FROM api_logs
WHERE timestamp >= NOW() - INTERVAL '7 days'
GROUP BY DATE_TRUNC('hour', timestamp), endpoint
ORDER BY hour DESC, endpoint
Automation
Continuous integration
A CI workflow compiles, runs and tests the project on every pull request, and deploys from main:
# .github/workflows/analytics-ci.yml
# Learn more: https://docs.github.com/en/actions
name: Analytics CI/CD
on:
push:
branches: [main]
paths: ["**.visivo.yml"]
pull_request:
paths: ["**.visivo.yml"]
jobs:
validate:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: "3.12"
- name: Install Visivo
run: pip install visivo
- name: Validate configuration
run: visivo compile
- name: Run queries and tests
run: |
visivo run
visivo test
deploy:
needs: validate
if: github.ref == 'refs/heads/main'
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: "3.12"
- name: Install Visivo
run: pip install visivo
- name: Run the project
run: visivo run
- name: Deploy to staging
run: visivo deploy -s staging
env:
VISIVO_TOKEN: ${{ secrets.VISIVO_TOKEN }}
- name: Deploy to production
run: visivo deploy -s production
env:
VISIVO_TOKEN: ${{ secrets.VISIVO_TOKEN }}
Monitoring
A Visivo alert runs after visivo test and notifies its destinations when its if condition is true:
# monitoring/alerts.visivo.yml
alerts:
- name: api-data-tests-failed
if: ">{ anyTestFailed() }"
destinations:
- name: slack_engineering
type: slack
webhook_url: ${env.SLACK_WEBHOOK_URL}
Run visivo test on a schedule (for example in CI) to turn your tests into data monitoring.
Performance
Performance work starts from the SQL Visivo generates:
# Read the SQL Visivo sends for each insight, then run EXPLAIN on it in your database
visivo compile
# Control how many queries run in parallel
visivo run --threads 8
# Rerun only the dashboard you are tuning
visivo run --dag-filter "'Engineering Metrics'+"
What the team gets
A shorter learning curve
Familiar tools: Developers use the editors, workflows and practices they already know. Gartner research shows that by 2025, 70% of organizations will shift their focus from big data to small and wide data, which makes developer-friendly tools more important, not less.
Consistent patterns: Analytics development follows the same patterns as application development.
Transferable skills: What you learn building dashboards applies to the rest of your work.
Scale
Modular components: Charts, Insights and models compose into larger dashboards.
Shared definitions: Metrics, dimensions, and relations in the semantic layer are defined once and reused by every Insight.
Automated generation: Similar dashboards can be generated programmatically rather than built by hand.
Quality
Code review: Analytics changes go through the same review process as application code.
Automated testing: visivo test checks the values behind your charts on every change.
Version control: Full change history, so you can debug and roll back.
Speed
Local development: Build and test dashboards locally before deployment.
Preview environments: Stakeholders review changes before they reach production.
Automated deployment: Changes deploy after they pass tests and review.
What to measure
Developer-centric BI with Visivo targets improvements like these:
Developer productivity
- Faster onboarding for developers new to analytics
- More dashboards shipped per week
- Less time spent on dashboard maintenance
- Fewer errors in dashboard logic
These line up with DORA metrics, which show that elite performers have significantly lower change failure rates.
Quality and reliability
- Fewer production issues with dashboards
- A complete audit trail for every analytics change
- High test coverage for data quality and dashboard behavior
- Faster resolution of analytics issues
Team collaboration
- More cross-team collaboration on analytics projects
- Knowledge shared through code and comments, not tribal memory
- Consistent development practices across teams
Business impact
- Faster delivery of analytics features to stakeholders
- More time for analysis
- Less analytics technical debt
- Higher stakeholder satisfaction with analytics delivery
Getting started
Phase 1: Foundation (Week 1-2)
Set up the basic developer workflow:
- Set up the development environment: Install the Visivo CLI and configure local development
- Convert one dashboard: Migrate one important dashboard to Visivo YAML
- Establish the Git workflow: Put the configuration under version control (see BI version control best practices)
- Add basic tests: Start with simple validation and data quality tests
# Quick start for existing developers
pip install visivo
visivo init --project-dir my-analytics-project --bare
cd my-analytics-project
# Configure first dashboard
vim project.visivo.yml # Add data sources and basic models
visivo serve # Start local development server
visivo test # Validate configuration
# Version control setup
git init
git add .
git commit -m "Initial analytics project setup"
git remote add origin https://github.com/company/analytics.git
git push -u origin main
Phase 2: Integration (Week 3-4)
Connect analytics development to the workflows you already have:
- IDE setup: Configure the editor for Visivo development
- CI/CD integration: Add analytics validation to existing pipelines (see CI/CD analytics implementation)
- Code review process: Agree on review criteria for analytics changes
- Documentation: Write down the team's analytics development standards
Phase 3: Advanced patterns (Week 5-8)
- Modular architecture: Organize large projects with includes and the semantic layer
- Environment management: Set up development, staging, and production configurations (see managing staging production environments)
- Automated testing: Build out test suites for data quality and dashboard behavior
- Monitoring and alerting: Add production monitoring for the analytics stack
Phase 4: Optimization (Week 9-12)
- Performance optimization: Tune queries and dashboards with the SQL
visivo compileproduces - Shared definitions: Build reusable metrics and dimensions for common patterns
- Advanced automation: Automate generation and deployment of analytics
- Team scaling: Roll the practice out across teams
Conclusion
Developer-centric BI turns analytics from hand-built reports into an engineering discipline. With Visivo, the tools are the ones developers already use: an editor, Git, a CLI and CI.
The benefits reach past individual productivity:
- Faster delivery of analytics features
- Higher quality dashboards with fewer errors
- Better collaboration between data teams and engineering
- Practices that scale with team size and complexity
- Less technical debt, because the same rigor applies everywhere
Teams that work this way get more than better dashboards. They get a data practice that is reviewed, tested and versioned like the rest of their software. The transition takes some investment in tools and habits, and the payoff shows up on the first reviewed pull request.
For more on scaling the practice, see our guides on faster feedback cycles and developer-first BI workflows.
If you want to try it, /get-started covers the install, and visivo init --example ev-sales gives you a working project to read before you write your own.