7 Live Dashboard Examples (With SQL and Refresh Intervals)

· 9 MIN

TL;DR: A live dashboard is a dashboard that re-runs its queries automatically, so the numbers stay current without anyone clicking refresh. The hard part is not the chart, it is picking the right refresh interval per metric: orders and errors every minute, signups every 15 minutes, revenue and churn hourly or daily. With AI for Database you build each tile by asking a plain-English question about your own database, and the dashboard refreshes itself on a schedule.

Try AI for Database free at aifordatabase.com: start with sample data.

A live dashboard (also called a real-time dashboard or live KPI dashboard) shows metrics that update on their own, either on a fixed interval such as every 5 minutes or on every page view. Most "live" dashboards are not truly streaming: they re-query the database on a schedule. That is fine for almost every business metric, as long as the interval matches how fast the number changes and how fast someone can act on it. The seven live dashboard examples below each list the scenario, the tiles, the Postgres query behind the main tile, and the refresh interval that makes sense.

What Is a Live Dashboard?

A live dashboard is a screen of metrics whose queries re-run automatically at a set interval, so viewers always see recent data. Tools implement it differently:

So "live" ranges from every few seconds to twice a day depending on the tool. Our glossary entry on dashboard auto-refresh covers the mechanics in more detail.

A scheduled live dashboard re-runs its query, updates the tile and checks alert rules on every cycle
FIG 01 — Each cycle costs one query per tile, so slow metrics should refresh less often.

How AI for Database Builds Self-Refreshing Tiles

AI for Database connects to PostgreSQL, MySQL, SQL Server, Supabase, BigQuery, MongoDB and other sources, read-only. You build a tile by asking a question such as "Show me orders per minute for the last hour". It writes the SQL, runs it, shows the result with its SQL, and you pin it to a dashboard. The dashboards are self-refreshing: they re-run on a schedule, so nobody re-runs reports by hand.

Two things matter for the examples below:

  1. Every tile shows its SQL, so an engineer can check the query you get from a plain-English question. The SQL in this article is the kind of query you would see.
  2. Action workflows watch the same data. You can define a condition ("when daily signups drop below 50") and an action (Slack alert, email or webhook). A live dashboard is only useful when someone is looking at it; an alert covers the hours when nobody is.

Pricing: start free with sample data, then 100 free queries on your own database; Pro is $10 per user per month (pricing, read 2026-10-23).

How Often Should Each Metric Refresh?

A live dashboard should refresh as often as someone can act on the change, and no faster. Use this table as a starting point:

ExampleMain metricRefresh intervalWhy
1. Live ordersOrders per minute1 minuteCheckout outages show up in minutes
2. App errorsFailed jobs, error rate1 minuteOn-call needs to see spikes now
3. Signups todaySignups vs same time yesterday15 minutesHourly patterns, slow to act on
4. Support queueOpen tickets, oldest wait5 minutesStaffing decisions within the hour
5. InventoryItems below reorder point1 hourReorders take days anyway
6. Revenue (MRR)MRR, new vs churnedDailyChanges with billing events
7. Sales pipelineDeals by stage1 hourReps update CRM a few times a day

Every refresh re-runs every query on the dashboard, so a 10-tile dashboard on a 1-minute interval sends 600 queries an hour to your database. Split fast and slow metrics onto separate dashboards rather than refreshing everything at the fastest rate.

1. Orders per Minute During a Sale

Scenario: an ecommerce team watches checkout during a sale. If orders per minute drop to zero, payments are probably broken.

Tiles: orders per minute (last 60 minutes), revenue today, average order value today, orders by payment method.

-- Orders per minute for the last hour
SELECT date_trunc('minute', created_at) AS minute,
       count(*) AS orders,
       sum(total_amount) AS revenue
FROM orders
WHERE created_at >= now() - interval '1 hour'
GROUP BY 1
ORDER BY 1;

Refresh: 1 minute. Adapt it: add WHERE status = 'paid' if failed checkouts are stored in the same table. Pair it with an alert: "when orders in the last 10 minutes = 0 during business hours, post to Slack".

2. Application Errors Dashboard

Scenario: a SaaS team logs background jobs in a jobs table and wants to see failures as they happen.

Tiles: error rate per 5 minutes, failed jobs by type, longest-running job.

-- Job failure rate in 5-minute buckets, last 2 hours
SELECT date_bin('5 minutes', finished_at, timestamptz '2000-01-01') AS bucket,
       count(*) FILTER (WHERE status = 'failed') AS failed,
       count(*) AS total,
       round(100.0 * count(*) FILTER (WHERE status = 'failed') / count(*), 1) AS error_pct
FROM jobs
WHERE finished_at >= now() - interval '2 hours'
GROUP BY 1
ORDER BY 1;

Refresh: 1 minute. date_bin needs PostgreSQL 14 or later; on older versions use date_trunc('minute', ...). Adapt it: for slow queries on SQL Server, see our guide to alerting on long-running SQL Server queries.

3. Signups Today vs Yesterday Dashboard

Scenario: a founder checks if today's launch or campaign is working. Raw counts mislead in the morning; compare against the same time yesterday.

Tiles: signups so far today, signups by this time yesterday, signups by source.

-- Signups today vs yesterday up to the same time of day
SELECT
  count(*) FILTER (WHERE created_at >= date_trunc('day', now())) AS today,
  count(*) FILTER (WHERE created_at >= date_trunc('day', now()) - interval '1 day'
                     AND created_at <  now() - interval '1 day') AS yesterday_same_time
FROM users
WHERE created_at >= date_trunc('day', now()) - interval '1 day';

Refresh: 15 minutes. Adapt it: group by utm_source to see which channel is moving. Time zones matter: date_trunc('day', now()) uses the session time zone, so set it to your business time zone.

4. Support Queue Dashboard

Scenario: a support lead decides whether to pull someone onto tickets. The metric that matters is the oldest unanswered ticket, not the total count.

Tiles: open tickets, oldest waiting ticket, tickets opened in the last hour, open tickets by priority.

-- Open tickets and the oldest wait, by priority
SELECT priority,
       count(*) AS open_tickets,
       max(now() - created_at) AS oldest_wait
FROM tickets
WHERE status = 'open'
GROUP BY priority
ORDER BY oldest_wait DESC;

Refresh: 5 minutes. Adapt it: set an alert when oldest_wait passes your SLA, for example 4 hours for normal priority.

5. Inventory Below Reorder Point Dashboard

Scenario: an operations manager wants to see which products need reordering before they sell out.

Tiles: items below reorder point, days of stock left per item, stock value.

-- Items below reorder point with days of stock left (based on last 14 days of sales)
SELECT p.sku,
       p.stock_on_hand,
       p.reorder_point,
       round(p.stock_on_hand / NULLIF(s.units_14d / 14.0, 0), 1) AS days_left
FROM products p
LEFT JOIN (
  SELECT product_id, sum(quantity) AS units_14d
  FROM order_items
  WHERE created_at >= now() - interval '14 days'
  GROUP BY product_id
) s ON s.product_id = p.id
WHERE p.stock_on_hand <= p.reorder_point
ORDER BY days_left NULLS LAST;

Refresh: 1 hour. Reorders take days, so minute-level refresh only adds load.

6. MRR by Plan

Scenario: a SaaS founder wants MRR, new MRR and churned MRR without waiting for a monthly spreadsheet.

Tiles: current MRR, new MRR this month, churned MRR this month, MRR by plan.

-- Current MRR by plan from active subscriptions
SELECT plan,
       count(*) AS customers,
       sum(CASE WHEN billing_interval = 'year' THEN amount / 12.0 ELSE amount END) AS mrr
FROM subscriptions
WHERE status = 'active'
GROUP BY plan
ORDER BY mrr DESC;

Refresh: daily, or hourly at most. MRR only moves with billing events. For the full set of retention metrics, see SaaS customer retention metrics.

Annual subscriptions are divided by 12 so they count as monthly revenue in the MRR tile
FIG 02 — The yearly Pro plan adds 10 to MRR, not 120.

7. Sales Pipeline Dashboard

Scenario: a sales lead runs the Monday pipeline review from the database instead of a CRM export.

Tiles: open pipeline by stage, deals won this month, deals with no activity in 14 days.

-- Open pipeline value by stage, plus stale deals
SELECT stage,
       count(*) AS deals,
       sum(amount) AS pipeline_value,
       count(*) FILTER (WHERE last_activity_at < now() - interval '14 days') AS stale_deals
FROM deals
WHERE status = 'open'
GROUP BY stage
ORDER BY pipeline_value DESC;

Refresh: 1 hour. More examples of company-wide tiles are in our company metrics dashboard guide.

What Metrics Belong on a Real-Time Dashboard?

A real-time dashboard should hold only metrics where a change in minutes leads to an action in minutes: orders, payments, errors, queue length, uptime. Revenue, churn, retention and pipeline belong on dashboards that refresh hourly or daily. Putting MRR on a 1-minute refresh does not make it more accurate; it adds database load and trains people to stare at numbers that cannot move.

Which Example Should You Use?

If you need to...Start withInterval
Catch a broken checkout1. Live orders1 min
Catch failing jobs2. Application errors1 min
Judge a launch or campaign today3. Signups vs yesterday15 min
Staff a support queue4. Support queue5 min
Prevent stockouts5. Inventory1 hour
Report revenue6. MRRdaily
Run a pipeline review7. Sales pipeline1 hour

How Do I Build One From My Own Database?

  1. Connect a read-only database user (never the app's write user).
  2. Write one query per tile, filtered to a time window (now() - interval '1 hour') so each refresh scans little data.
  3. Index the timestamp column you filter on, for example CREATE INDEX ON orders (created_at);.
  4. For heavy aggregates, precompute them in a materialized view and refresh it on a schedule. In PostgreSQL, REFRESH MATERIALIZED VIEW CONCURRENTLY refreshes without locking out readers, but it needs a unique index on the view (PostgreSQL docs).
  5. Set the refresh interval per dashboard from the table above.
  6. Add alerts for the metrics that matter when nobody is looking.

In AI for Database, steps 2, 5 and 6 are a question, a schedule and a workflow condition. Our page on dashboards and reports shows the flow.

Frequently Asked Questions

What is a live dashboard?

A live dashboard is a dashboard whose queries re-run automatically on a schedule or on each view, so its metrics stay current without manual refreshes.

How often should a live dashboard refresh?

As often as someone can act on a change: 1 minute for orders and errors, 5-15 minutes for queues and signups, hourly or daily for revenue, churn and pipeline.

Is a live dashboard the same as a real-time dashboard?

Mostly. Strictly, real-time means streaming each event as it happens; most live dashboards poll the database every few seconds or minutes, which is close enough for business metrics.

Does a live dashboard slow down my database?

It can. Every refresh re-runs every tile's query. Filter to recent time windows, index timestamp columns, point dashboards at a read replica, and use slower intervals for heavy queries.

Can I get alerts instead of watching a dashboard?

Yes. In AI for Database, action workflows check a condition on your data and send a Slack message, email or webhook when it is met, so the dashboard is for context and the alert is for action. Try AI for Database free at aifordatabase.com: [connect your database or use the sample data](https://app.aifordatabase.com/signup) and build your first self-refreshing dashboard from a plain-English question.

Ready to try AI for Database?

Query your database in plain English. No SQL required. Start free today.