Analytics as Code

Ship your analytics like software

Your models, metrics, and dashboards live as code in Git. Branch, review, and release every change the way engineers ship software.

Read the docs
Book a demo
Analytics defined as code in Holistics
See our customers

Define everything as code

Every model, metric, and dashboard is a plain-text definition, tracked in Git and compiled to your warehouse's native SQL. Nothing trapped in a UI, no logic copy-pasted between dashboards.

Models & datasets

Tables, dimensions, measures, and the relationships between them.

Model orders {
  dimension status { type: 'text' }
  dimension amount { type: 'number' }
  measure count {
    definition: @aql count(orders.id) ;;
  }
}
Dataset sales {
  relationships: [
    relationship(
      orders.user_id > users.id)
  ]
}

Metrics

Composable metric definitions in AQL, defined once and reused everywhere.

Metric total_orders {
  definition: @aql count(orders.id) ;;
}

Metric gmv {
  definition: @aql sum(items.amount) ;;
}

Metric aov {
  definition: @aql gmv / total_orders ;;
  format: "[$]#,###0"
}

Dashboards and charts

Canvas layout, blocks, filters, and chart types, all in code.

Dashboard revenue {
  block kpi: VizBlock {
    viz: KPIMetric {
      dataset: sales
      value: gmv
    }
  }
  block trend: VizBlock {
    viz: LineChart {
      dataset: sales
    }
  }
}

Row-level permissions

Access rules written in code and reviewed like any other change.

Dataset sales {
  permission regional_access {
    field: r(orders.region)
    operator:
      'matches_user_attribute'
    value: 'region'
  }
}

Themes and palettes

Reusable dashboard themes and color palettes, versioned with the rest.

PageTheme brand_theme {
  color { data: brand }
}

ColorPalette brand {
  categorical {
    colors: ["#4F46E5", "#22C55E"]
  }
}

Context for AI

Descriptions, definitions, and lineage that give AI agents the context to answer from real business logic.

const ai_context = @md
  ## Business rules
  Default dataset: ${sales}
  Revenue is net of refunds.
  ${ if (H.current_user.team == 'Finance') {
       'Fiscal year starts in April.'
  } }
;;
“The semantic layer is Holistics' biggest draw because I was able to build reusable models, dimensions, metrics, and then describe them as code.”
Sterling Paramore

Sterling Paramore

Sr Staff Data Engineer, Mainspring Energy

Why code

Write it as code, and the rest is inherited

Ownership

Plain-text definitions in your own Git, compiled to SQL on your own warehouse. Nothing proprietary to migrate out of if you leave.

Open semantic layer

Collaboration

Branch, propose, and review every change in a pull request. Teams work in parallel instead of taking turns in one shared workspace.

Code review

Governance

History, review, environments, and rollback on every definition, so business logic gets the same rigor as production code.

Version control

Control

Search, rename, and refactor across the whole project in one commit. A UI or API touches one object at a time; code touches as many as you need.

Code search

Automation

CI type-checks every change and blocks breaks. Auto-publish ships on merge. Releasing analytics runs on its own.

CI/CD

Amplified by AI

It all compounds when AI writes the code: agents edit real definitions, reuse reviewed logic, and ship through the same checks as everyone.

Agentic development
The workflow

From idea to production, the way engineers work

Because your analytics is code, every change moves the way software ships, and inherits decades of Git tooling for free.

Full version history

Every model, metric, and dashboard has a complete history. See what changed, when, and by whom, and roll back instantly.

Version control docs

Pull request reviews

Changes are proposed, diffed, discussed, and approved before they reach production. No silent edits to a shared workspace.

Code review docs

CI/CD validation

Compile and type-check on every PR, block breaking changes, and auto-publish on merge through the Validation and Publish APIs.

CI/CD docs

Isolated environments

Dev, staging, and production each point at their own data source, so you test on real structure without touching production.

Dev/prod environment docs
Reuse and compose logic with the programmable semantic layer
“The ability to track changes on dashboards via the Git integration is great! This would allow us to design the dashboards more individually.”
Thi Ng.

Thi Ng.

Lead Product Manager, Dbdiagram

Edit it by hand, by click, or by prompt

As code doesn't mean everyone writes code. The same governed project is editable three ways, and every path commits the same reviewable AML.

The GUI and the code, always in sync

Every model, dataset, and dashboard is both a GUI object and an AML file. Change one and the other updates.

Being able to create charts in visual view and look at the code, and vice versa is really useful. It's like when you're in Excel, you can record a macro, do your stuff, and then come back and look at the code. That's how it should work.
Mike K.
Mike K. Director of Enterprise Analytics, Strongmind

Build your BI dashboards with coding agents

Use Claude, Codex, or Cursor locally, or our Copilot in the browser, to build models, metrics, and dashboards.

Explore agentic development
secure.holistics.io/reports/revenue-dashboard

Live preview

Your dashboard will build here

claude · ~/analytics
>
⠋ Build Revenue dashboard (0m 00s · ↓ 0.0k tokens)
› esc to interrupt · ctrl+t to hide tasks
Open by design

Your logic, your Git, your warehouse

Because it's code, you own your analytics outright, and it runs on the stack you already have.

Plain-text in your own Git

Host it on GitHub, GitLab, or Bitbucket. It's your repository.

Inspectable compiled SQL

Every query compiles to native SQL you can read and check.

Runs on your warehouse

Nothing is copied out. Queries run where your data already lives.

Export anytime

It's just files. Nothing proprietary to migrate out of.

Not even locked into our UI

Query your governed metrics from the API and CLI, not only the Holistics interface.

Works with dbt

Build metrics and dashboards on top of the dbt models you already have.

“Holistics's dbt integration was the biggest draw for me and demonstrates a clear understanding of where the modern data stack is headed.”
Stuart Shiell

Stuart Shiell

Lead Data Insight, Semios

What teams shipping analytics as code say

Holistics effectively allows us to be repeatable. We add a new client, copy and paste all the data models, and change the data source. Done!

David Aldred

Insight Director, Retail Insight

David Aldred
Holistics felt like a Looker that is still being developed and going somewhere, not being mothballed by Google or becoming a cog in an over-engineered stack.

Max Pagel

CTO, SensorFlow

Max Pagel
I just build a few models and write descriptions, and people from different departments have been using them to build reports throughout the years without having to ask me or the IT team.

Martin Dell

Founder, Kyero

Martin Dell

Frequently asked questions

Isn't this just dbt or Terraform for BI?
dbt models your transformations and Terraform provisions infrastructure. Holistics as code covers the BI layer on top: metrics, dashboards, and permissions, in one typed language that compiles to SQL. It builds on your dbt models instead of duplicating them.
Do I have to write code to use Holistics?
No. You can build everything by clicking in the workspace, and it commits as code underneath. Writing AML by hand is there when you want the speed of bulk edits, refactors, and reuse.
Can non-technical users still explore data?
Yes. The code defines a governed model; business users explore it through drag-and-drop dashboards and self-service, without ever touching a file.
How do changes reach production?
The same path as software. Commit on a branch, then publish to production manually, through the Publish API, or automatically on merge. Connect your own Git provider to require a reviewed, approved pull request before anything ships.
Do I need to bring my own Git provider?
No. Every project is version-controlled the moment you start, with branches, full history, and diffs built in. Connect GitHub, GitLab, or Bitbucket when you want pull requests and branch protection to live in your own provider.
Which data warehouses does it run on?
Your models compile to native SQL that runs on your warehouse: PostgreSQL, Redshift, BigQuery, Snowflake, Databricks, SQL Server, and ClickHouse. Nothing is copied out of it.
Can I develop locally, in my own editor?
Yes. The Holistics CLI syncs your project to your machine, the VS Code extension adds autocomplete and inline validation, and coding agents like Claude Code and Cursor connect over MCP.

See it on your data

A 30-minute walkthrough with a Holistics engineer. We'll connect a sample of your warehouse and ship a change from a pull request to a live dashboard.

Read the docs Book a demo