Dune Analytics Dashboards: Where On-Chain Data Analytics Breaks
Let's show a typical failure. Management asks for transaction and unique address numbers for the quarter across several networks at once. An engineer exports CSV from a block explorer, consolidates in a spreadsheet manually, cleans duplicates. The answer arrives in three or four days — and some of the numbers are already outdated by then.
As soon as one metric is calculated by two people, on-chain analytics turns into reconciliation. Snapshot moments diverge: one report captured the block before, another after.
Address labels diverge: exchange wallet, treasury, contract are different for everyone, so "active user" means different things in two reports.
A separate headache is internal transfers and tokens. One event produces several rows or none at all, token decimals differ, and amounts in manual exports do not reconcile to the third decimal.
Reconciling this after the fact is almost impossible: the original export has already been overwritten.
The cost of this scheme is not only engineers' hours. Decisions are made on data a week old, and transaction reporting cannot be reproduced — which means it is not an argument in a conversation with an investor or auditor.
Dune Analytics dashboards remove the manual assembly itself: queries go to decoded tables, a metric is defined once and updated on schedule, and the address label directory is shared by everyone. Below we break down exactly where blockchain data analytics breaks and what closes it.
Dune Analytics for the Task: What Changes in the Team's Work
Dashboard on Dune Analytics — not a set of charts, but an access layer to on-chain data. On-chain metrics are defined once — in queries over indexed tables and materialized views — and any report takes an already calculated value. A single data source removes the question "whose number to trust in the meeting."
Report preparation speed changes severalfold. Previously an export was assembled manually from several places and had time to become outdated by the presentation; now updates run on schedule, and the period, network, and contract address are set as a dashboard parameter.
A new direction is added as a separate block, without rebuilding the entire dashboard and re-reconciling numbers.
Task-specific analytics removes a whole class of errors — discrepancies from manual consolidation. While a metric was calculated in each analyst's personal spreadsheet, two teams got different values because of different filters, rounding, and snapshot moment.
When the formula is fixed in a shared layer, the dispute is about interpretation of the indicator, not arithmetic.
The load on engineers drops: questions like "how much was there last period" and "how did the share of active addresses change" are closed by access to custom dashboards, without one-off queries and code edits.
We define metrics, thresholds, and access separation, and the team then works with the numbers independently — without a developer as intermediary.
Ready-Made Templates, Custom Panels, or Your Own Index: What to Choose
Analytics on Dune Analytics is built on three levels, and the choice between them is the choice of who is responsible for the data layer: the platform, we in a panel over ready-made tables, or we in loading and modeling. The difference shows not in the charts, but in which questions to the data can be asked at all.
| Option | When it fits | Limitations |
|---|---|---|
| Public template | Metric is typical: protocol turnover, inflows and outflows, address activity | Calculation is set by the template author — you cannot add your own filter, your own metric, or internal labels to it |
| Custom panel on ready-made data | You need your own breakdown and presentation, while source tables are already loaded and updated by the platform | Limited by available datasets and their update latency; discrepancies with internal accounting cannot be closed |
| Own data model with regular loading | You need fields absent from public datasets: address labeling, internal identifiers, data from your own infrastructure | Requires maintenance: control of each load, duplicate elimination, history recalculation, missing-load alerts |
Choice comes from the question, not the tool. If a metric matches a typical one, a template closes the task and almost requires no support. When it is about presentation and breakdowns, a custom panel over ready-made tables is enough.
An own model is needed where data has to be collected and normalized yourself: then the panel becomes a superstructure, and the main work goes into loading and quality — we break this down at the assessment stage.
Work Stages: From Data Audit to Dashboard Handover
Work starts not with charts, but with questions: what decisions are made based on the metrics and what we consider the correct answer.
Then the panel is assembled as a service — with a data schema, number checks, and query versioning, so the result can be reproduced, handed over, and developed.
- Business question breakdown. We fix the decisions that will be made based on the panels and turn them into a list of metrics with an unambiguous definition for each — without "overall activity" and other vague formulations.
- Data source audit. We check which Dune Analytics tables cover the needed contracts and events, whether decoded logs exist, and whether history is complete from launch. If coverage is absent, we describe what will have to be decoded independently.
- Metric schema. For each number we set a formula: which events we take, which addresses we exclude (bridge, treasury, bots), how we count unique participants, and how we avoid duplicates during recalculation.
- Panel assembly. We write queries, configure charts, filters by networks and periods, add captions with metric definitions — so the same number cannot be interpreted in two ways.
- Metric consistency check. We reconcile totals with raw data and independent sources, investigate discrepancies down to the cause rather than smoothing them over with rounding or narrowing the period.
- Dashboard handover. We provide accesses, documentation, queries with comments, train the team, and leave an edit procedure in case contracts change.
Each stage leaves an artifact: metric definition, query, reconciliation result. This removes the main problem of blockchain analytics — when different panels calculate the same thing differently, and there is no trust in any of them.
What You Keep: Documentation, Schemas, and Procedures
We hand over not only accesses, but the entire context by which the analytics dashboard on Dune lives on without us. This is working documentation, not a folder of exports: from it a new analyst deploys reporting and understands where every number came from.
- Metric model — what each indicator calculates: formula, source, granularity, which segments are excluded. Discrepancies in reports are investigated using this description, not the author's memory.
- Data schema — relationships between tables, join keys, and places where duplicates arise; separately indicated is how we remove them during consolidation.
- Data access rules — roles and separation by rows and slices, the procedure for granting and revoking rights, including when an employee leaves.
- Metric update procedure — recalculation frequency, who confirms a formula change, what we do when a source is edited.
- Quality check catalog — tests for gaps, negative values, and breaks in series. A check fails before management sees a distorted number.
- Team instructions — how to add a metric, fix a query, view build history, and roll back to a previous version.
- Change log — query version, author, and reason for the edit, so that six months later it is clear why the metric is calculated exactly this way.
The kit is written in your team's language and updated together with the report: any formula change first goes into documentation, then into the dashboard.
Case: How On-Chain Metric Reporting Speed Increased
The client is a product with on-chain activity: transfers, holder distribution, contract dynamics. Reports on these metrics were assembled manually — exports from block explorers, address reconciliation, consolidation in spreadsheets.
A weekly snapshot took two working days of an analyst, and any edit at a manager's request triggered collection from scratch.
The losses were not in export speed, but in agreeing on definitions. The same indicator was calculated differently for the report and for the internal panel, so numbers differed between documents: reconciliation took another day.
Every new question like "how many active addresses were there last month" turned into a separate task from scratch — with the same manual work.
On Dune we assembled a single query layer: metric definitions were fixed once, reusable tables update on schedule, and on top of them are panels for specific roles. Then we compared metrics before and after.
| What we measured | Before | After |
|---|---|---|
| Weekly report preparation | 2 working days | 3 hours |
| Panel update after a request | 1–2 days | minutes |
| Number discrepancies between reports | regular | reduced to zero |
| New metric in reporting | 1–2 days | 2–4 hours |
Report preparation speed stopped depending on analyst workload: the panel opens at any moment, not once a week. Definition edits are now made in one place and immediately visible in all slices. The team spends the freed time on analyzing data, not consolidating it.
What to Do If Reporting Is Already Assembled on Another Platform?
Reporting on another platform is not a reason to break it.
While the old contour is considered correct, it remains the source of truth, and the new one grows alongside: analytics migration almost never happens in one day, because query models, directories, and aggregation logic move in portions, and at every step metrics must reconcile with the previous ones within understandable limits.
There are three transition formats, and the choice is determined by how often metric definitions change and who makes decisions based on the numbers.
A practical guideline: with live metric definitions, start with a parallel contour — it provides room for reconciliation; with stable logic, phased transfer is cheaper in engineer time; full transfer is justified when the old contour is no longer read.
We transfer dashboards with filters and slices, document discrepancies between Dune and the previous platform, and reconcile until key indicators match.
Doubts About Load, Access, and Dashboard Support
Dashboards on Dune Analytics are SQL queries over indexed blockchain data and marts that we assemble ourselves. Below are four questions that most often arise before acceptance: privacy, report behavior as volumes grow, access rights, and maintenance.
How protected is our data?
Public networks are open anyway, so privacy concerns internal marts: addresses, client labels, portfolio calculations. We keep them in the team's private space, grant access via service keys with minimal rights, and only aggregates go to external dashboards.
What will happen to reports as volumes grow?
Heavy queries scan millions of rows and hit the time limit. We materialize intermediate tables, recalculate only new blocks, and move aggregates into separate marts — charts open quickly, and history depth does not slow updates.
How to separate access between teams?
We configure rights at three levels: workspace, queries, individual dashboards. An analyst sees source tables, a manager sees only charts, a contractor sees a specific set of queries. Roles are described in configuration and transfer to a new account without manual reconfiguration.
Who supports dashboards after delivery?
Indexers change the event schema, contracts update — queries without maintenance break silently. We hand over documentation for each query, set alerts for failed updates, and fix logic when contracts change.
Let's Discuss Your Task and Come Back with a Work Plan
To make dashboard assessment substantive, a short introduction is enough for the first conversation — we will clarify the rest on a call. Below is what helps immediately see the scope of analytics work and avoid spending the meeting on gathering basic data.
- Metrics and questions: which indicators are needed and what decision is made based on them — this determines query granularity and the set of visualizations.
- Sources: networks, contract addresses, and wallet pools we count by; whether ready-made exports exist for reconciliation.
- Access: a read-only Dune key, roles in the repository, and test queries if analytics is already underway.
- Frequency and depth: how often data updates and what period of history is needed.
- Readers: who opens the dashboard and what takeaway they should leave with — risk team, product team, or external partners.
- Output format: whether export to tables and regular distribution are needed, or a page with filters and slices is enough.
On the call we will break down how we reconcile numbers with on-chain data, how we handle block reorgs and late transactions, and where the boundary lies between on-chain and calculated metrics.
After that we will come back with an analytics work plan: query composition, stages, acceptance procedure, and what you will be able to support on your own. Describe your task — we will discuss it and come back with an estimate and plan.