Dashboard development goes wrong in the first week, not the last. The grain of the data, "exactly what a single fact table row represents" in the Kimball Group's definition, is decided before any chart exists, and most teams decide it by accident when a developer writes the first query. In Retool's 2022 State of Internal Tools survey of 2,285 people, operations was the team internal tools were most often built for (55%), and only 27% of respondents used a BI tool beyond standard analytics, so most of these dashboards are built by hand on whatever tables exist.
This guide walks through an operations dashboard in the order we would build one: the question, the grain, the data model, the refresh and permission rules, then the charts. It prices a build against Metabase, Power BI and Grafana at three team sizes and ends with a six-week plan. Where a figure is ours, it says so.
Why dashboard development starts with a question, not a chart
The Nielsen Norman Group describes a dashboard as a single page "focused on a single task: communicating critical information", and separates two kinds. An operational dashboard supports time-sensitive, immediate decisions: which orders are late today, which queue is over its limit. An analytical dashboard supports analysis done later: why returns rose last quarter. They need different freshness and usually different screens, and the most common failure we see is a page that tries to be both.
So the first deliverable is not a wireframe. It is one sentence per screen: who looks at it, how often, and what they do when a number is wrong. "The fulfilment lead checks it at 8:00 and reassigns pickers when any carrier's late rate passes 5%" is a specification. "A real-time view of operations" is not. Our post on internal tool development makes the same case for any internal tool: the user list decides the price and the permission model before any feature does.
Retool's 2022 survey shows who asks: operations (55%) and customer support (52%) were the teams respondents built tools for most often, ahead of sales (39%). Those teams want decisions, not exploration. The sample was 87% Retool customers.
Declare the grain before anyone opens Figma
Ralph Kimball published the dimensional modelling method in 1996, and its four steps are the shortest useful checklist for dashboard development we know.
| Step | Kimball's wording | For a fulfilment dashboard |
|---|---|---|
| 1 | Select the business process | Picking and shipping orders, not "operations" |
| 2 | Declare the grain | One row per shipment event: picked, packed, handed to carrier, delivered |
| 3 | Identify the dimensions | Date, warehouse, carrier, product category, customer segment |
| 4 | Identify the facts | Minutes between events, units, cost, late flag |
Source: Kimball Group, Dimensional Modeling Techniques, four-step design process; the right-hand column is our example.
The grain is the commitment. The Kimball Group calls declaring the grain "the pivotal step in a dimensional design" and says every candidate dimension and fact must match it. "One row equals one shipment event" is written down before any column is named, and when a stakeholder later asks for "average time in warehouse", the grain says whether that is a query or a new table.
Store the atomic grain. Kimball recommends capturing the "lowest level at which data is captured by a given business process", because it answers questions nobody predicted. A dashboard built on nightly totals cannot answer "which carrier was late on Tuesday afternoon", and that request is where most second-phase budgets go.
Name things in business words. The Kimball page says governance representatives "must participate in this detailed design activity". For us that is one session with the fulfilment lead to agree names, allowed values and the rule behind each flag, written into the schema as comments.
Build or buy: what dashboard tools cost at three team sizes
The honest comparison is not features, it is the shape of the bill. BI tools price per viewer; a custom dashboard prices in developer hours and then costs almost nothing per viewer. We build applications in Next.js, so read our row with that bias in mind.
| Option | 10 users | 50 users | 200 users | Not included |
|---|---|---|---|---|
| Metabase Starter ($1,080 a year for 5 users, $65 a year each after) | $117 | $334 | $1,146 | Row-level permissions, SSO, embedding |
| Metabase Pro ($6,210 a year for 10 users, $130 a year each after) | $518 | $951 | $2,576 | Air-gapped deployment |
| Power BI Pro ($14 a user a month) | $140 | $700 | $2,800 | Fabric capacity |
| Grafana Cloud Pro ($19 with 3 users, $8 an active user after) | $75 | $395 | $1,595 | Usage over 10,000 series or 50 GB of logs |
| Custom: Supabase Pro plus Vercel Pro | $45 | $45 | $45 | The build and upkeep, in hours |
Source: metabase.com/pricing, Microsoft Power BI pricing, grafana.com/pricing, supabase.com/pricing and vercel.com/pricing, read 2026-11-09. Vendor list prices; overages and compute add-ons excluded.
Three lines in that table decide most projects.
The permissions line. Metabase puts row and column-level permissions, SSO and multi-tenant embedding on Pro, from $6,210 a year. If each warehouse may see only its own rows, Pro is the line to compare with a build.
Viewer count. Power BI is the simplest bill and the steepest curve: $14 a month for everyone who opens a report, or $33,600 a year at 200 viewers. Our Retool vs custom internal tool post plots the same crossover for an admin tool.
The flat line is not free. Supabase Pro starts at $25 a month with 8 GB of disk, and Vercel Pro is $20 a month per developer seat with unlimited viewer seats, so the pair costs about $45 a month whether 10 or 200 people open the dashboard. Everything else is hours: the build, then the upkeep.
The rule we would use: if viewers are fewer than 25, the data already sits in one database and nobody needs per-row permissions, open Metabase or Grafana and ship this week. If any of the three is false, price a build.
The data layer: Postgres, one summary table and one refresh rule
The database is rarely a debate. PostgreSQL was used by 55.6% of the 26,083 developers who answered Stack Overflow's 2025 database question, ahead of MySQL at 40.5%; Supabase, which is Postgres with an API, was at 6%. The real choices are how often a number is recomputed and where the cached copy lives.
| Option | How stale | Cost per page view | Use it for |
|---|---|---|---|
| Live query on the event table | Zero | Full query every view | Queues and counts that must be current |
| Cached page, time-based revalidation | Up to the revalidate window | One regeneration per window | Most operational screens, 60 to 300 seconds |
| Materialized view, refreshed on a schedule | Up to the schedule | One refresh per schedule | Aggregates over millions of rows |
| Nightly summary table | Up to 24 hours | Near zero | Trend charts and month-to-date comparisons |
Source: PostgreSQL 18 documentation on REFRESH MATERIALIZED VIEW; Next.js documentation on Incremental Static Regeneration, updated 2026-10-15; the classification is ours.
Materialized views carry the heavy aggregates. A materialized view stores a query's result and recomputes it on command. Per the documentation, a plain REFRESH "could block other connections which are trying to read from the materialized view", while REFRESH CONCURRENTLY refreshes without locking out readers, provided the view has a unique index on plain column names with no WHERE clause. So every summary view gets a unique index on its grain columns before the first scheduled refresh.
The page cache carries the rest. A Next.js route can export a revalidate value in seconds. After the window passes, the next visitor still gets the cached page while a fresh one is generated in the background; the docs recommend "a high revalidation time. For instance, 1 hour instead of 1 second", with revalidatePath or revalidateTag for the moments that need precision. A revalidate of 0 makes the route dynamic, so every view runs the query.
One refresh rule, written down. Each number on the screen gets a stated freshness: live, within 5 minutes, as of last night. Most "the dashboard is wrong" tickets are two numbers with different freshness sitting next to each other.
Permissions are a data problem, not a front-end one
An operations dashboard almost always has a row rule: a warehouse manager sees their warehouse. Hiding a filter in the interface is not that rule. Postgres row level security is: Supabase's documentation describes it as "granular authorization rules that run inside the database", applied like a WHERE clause to every query on the table whichever client sends it.
Four habits from that documentation keep the rule correct and fast.
- Grants and policies are separate checks. Enabling RLS does not remove existing grants, so the documented order is enable RLS, revoke everything from the API roles, then grant back only what each role needs.
- One policy per operation. Select, insert, update and delete each get a policy, with the role named in the TO clause so the expression never runs for roles it does not target.
- Index every column a policy filters on. Without one a read can fall back to a sequential scan; a column only counts if it leads a btree index.
- Wrap helper calls in a select. Writing (select auth.uid()) instead of auth.uid() lets Postgres cache the value per statement instead of calling it on every row.
Supabase also recommends a pgTAP test file per table that checks allowed and denied access for each role and operation. It is the cheapest insurance in the project, because a permissions bug on a dashboard is silent: the manager just sees a number that is too big.
Charts last: the rules that survive every redesign
By week four the data model is stable and the first screen shows real numbers in plain tables. Only now are charts chosen, and two public guides do most of the work.
| Question | Chart | Rule it follows |
|---|---|---|
| How does today compare with the target? | Bar, axis at zero | Length is read most accurately; a broken bar axis distorts proportion |
| How has this moved over time? | Line, four series or fewer | More than four lines "often results in the chart becoming too cluttered" |
| Which carriers are late most? | Sorted horizontal bar | Position and length, not colour, carry the value |
| What share does each warehouse hold? | Bar, or a pie only with five or fewer categories and one dominant | Pie charts "should be avoided most of the time" |
| Are two measures related? | Two charts, not a dual axis | Dual-axis charts "can be easily misinterpreted" |
| Is anything over its limit right now? | Number with a threshold colour and a label | Colour reinforces but never carries the meaning |
Source: Nielsen Norman Group, Dashboards: Making Charts and Graphs Easier to Understand, 2017; UK Government Analysis Function, Data visualisation: charts, 2022.
NN/g's core rule is that length and two-dimensional position are the attributes people judge most accurately, colour should never carry magnitude, and area and angle (pie, donut, treemap, radial gauge) should be avoided for quantitative comparison. It notes that up to 4.5% of the general population has some form of colour blindness, about 8% of men and 0.5% of women, which is why a status colour always comes with a label. The Analysis Function guidance adds the accessibility floor for public bodies, WCAG 2.2 level AA, and the rule that colour must not be "the only way to match labels to data".
Picking a library. We pulled last-month download counts from the npm registry on 9 November 2026 for twelve charting packages. In the 30 days to 8 November, recharts had 219.2 million downloads, d3 103.0 million, chart.js 53.9 million and echarts 30.3 million. Downloads include CI installs and transitive dependencies, so they measure popularity, not sites in production. We would start with Recharts for a Next.js dashboard and move a single heavy chart to ECharts. The chart type is chosen from the question; the library just draws it.
A six-week dashboard development plan
This is how we would run an operations dashboard build in Next.js on Postgres. The gates are the point: each week ends with something a stakeholder can reject cheaply.
| Week | Work | Gate |
|---|---|---|
| 1 | One sentence per screen; grain declared; source systems and owners listed | Stakeholder signs the grain sentence and screen list |
| 2 | Event and dimension tables; names and rules as schema comments; sample data | Fulfilment lead reads ten rows and agrees what each means |
| 3 | Pipeline from source systems; materialized views with unique indexes; RLS policies and pgTAP tests | Every policy test passes; refresh runs on schedule |
| 4 | First screen in plain tables with real data and freshness stamps, no styling | Numbers match the source system to the row |
| 5 | Charts from the question table; thresholds and alerts; drill-down to event rows | Each chart answers its question in one look |
| 6 | Accessibility pass, load test on the largest view, handover notes, owner named | A new user completes the three daily tasks unaided |
Source: our plan; the sequence follows the Kimball steps and the Supabase and Next.js documentation cited above.
Two gates get skipped most often and cost the most later. Week two's ten-row reading is where misnamed statuses and double-counted events are caught. Week four's plain-table screen feels like a step backwards to stakeholders who expected visuals, and it is the only moment the numbers can be checked without a chart hiding the error. We have not published a dashboard case study yet, so treat the plan as our method rather than a measured record; our internal tools statistics post has the public data on comparable builds.
How to use this
Write the grain sentence and the screen list before asking anyone for a quote, because they decide whether you buy a BI seat or build. If the viewers are few, the data is in one place and everyone may see everything, buy the seat and spend the saved weeks on the data model anyway. If any screen needs per-row permissions, outside viewers or a brand the customer sees, price a build with the six gates above and insist on the week-four plain-table screen. Our web apps service page explains how we scope a dashboard like this and quote it per project.


