Advancing Dashboarding in Grafana

By Author — Updated: Sept 23, 2025 • 12 min read

We design dashboards that speak to both engineering teams and business leadership. In this article we share practical patterns and recipes to:

Why correlate multiple sources in the same dashboard?

Systems rarely live in a single observability tool. Infrastructure metrics may live in Prometheus, business metrics in an analytics DB, APM traces in Datadog/Dynatrace, and logs or security events in Splunk. Combining these signals into a single view lets us quickly answer operational and business questions such as:

Grafana supports mixed data sources and provides transformations to join and reshape queries — this enables correlation across systems without forcing a single backend. :contentReference[oaicite:0]{index=0}

Common patterns for multi-source dashboarding

1) Mixed-Panel pattern (multiple queries, single panel)

Use Grafana's Mixed datasource to add multiple queries (each query can target a different datasource) to the same panel. This is ideal for aligned time-series charts or tables where each series originates in a different system. Typical uses:

Advice: normalize time ranges and sampling resolutions, and use transformations (join, outer join, merge) to align series. Grafana docs and community posts explain how to work with multiple datasources in practice. :contentReference[oaicite:1]{index=1}

2) API-aggregation pattern (proxy / mediator)

When complex correlation or custom business logic is required (e.g., enrich APM traces with CRM events), we recommend an API-aggregation layer:

  1. We build a small service that fetches data from multiple vendor APIs (Datadog, Dynatrace, Splunk, custom timeseries DBs).
  2. That service merges, normalizes and exposes a single JSON/Prometheus endpoint tailored to the dashboard’s needs.
  3. Grafana consumes that endpoint using the JSON API datasource or Prometheus remote write (depending on the format).

This pattern centralizes transformations that may be difficult to express inside Grafana and makes dashboards reproducible and testable.

Example: simple Node.js aggregator (pseudo-code)


// This is illustrative. Replace with robust code for auth, retries, caching.
const express = require('express');
const fetch = require('node-fetch'); // or axios
const app = express();

async function fetchDatadog() {
  // call Datadog API (metrics/queries)
  return fetch('https://api.datadoghq.com/api/v1/query?from=...&to=...').then(r => r.json());
}
async function fetchSplunk() {
  // call Splunk (or Splunk HTTP Event Collector)
  return fetch('https://splunk.example/api/search?...').then(r => r.json());
}

app.get('/api/combined', async (req, res) => {
  const [dd, sp] = await Promise.all([fetchDatadog(), fetchSplunk()]);
  // normalize and merge by timestamp
  const merged = mergeByTimestamp(dd.series, sp.series);
  res.json({ series: merged });
});

app.listen(8080);

Grafana can consume /api/combined with a JSON datasource plugin (for example, the JSON API or SimpleJSON plugin) and visualize the merged series in a panel. Using an aggregator also lets us apply business logic (e.g., map user IDs to feature flags) before presenting it to executives.

3) Transformations & joins inside Grafana

If an aggregator is not desirable, Grafana's Transformations let you join query results at the panel level (outer join, merge, labels). This works well for tables or when you have matching keys across datasources. Be mindful of cardinality and performance when joining large tables in the browser. :contentReference[oaicite:2]{index=2}

Business-facing visualizations & Business Charts plugin

Technical teams and business stakeholders have different needs: engineers need high-cardinality, fine-grained traces and error windows; leadership wants clear KPIs, trends, and executive summaries. To bridge this gap we:

One widely-used suite is Volkov Labs' Business Charts (an Apache ECharts-based panel) and the broader Business Suite (Business Table, Business Input). These plugins enable advanced, code-driven charts and custom rendering for business dashboards. Their documentation and examples are a great resource. :contentReference[oaicite:3]{index=3}

Examples of business visuals

We recommend exporting Business Charts visualizations as reusable templates (panel JSON) and storing them in your dashboards-as-code repository.

Business Charts example (placeholder)
Example: Business KPI strip built with Business Charts (replace with your screenshot).

Best practices (engineering + product + leadership)

  1. Define the question first: each dashboard must answer 1–3 clear questions for its audience.
  2. Two-layer UX: summary KPIs at the top, drilldowns per system below.
  3. Consistent metrics & tags: enforce naming conventions and resource tags across teams so joins and filters work predictably.
  4. Dashboard performance: minimize heavy client-side joins; prefer pre-aggregated, paged data or server-side aggregation.
  5. Versioning & code: store dashboards as JSON / provisioning files, manage them with Git and CI (dashboards-as-code). See Grafana provisioning and API for automation. :contentReference[oaicite:4]{index=4}

Practical recipe: From vendor APIs to executive panel (step-by-step)

We follow a pragmatic 6-step recipe we use for clients:

  1. Inventory: list the data sources and confirm available APIs, metrics, and rates (Datadog, Dynatrace, Splunk, InfluxDB, SQL warehouses).
  2. Design the KPI: write a one-sentence question the KPI answers and its mathematical definition (e.g., "95th perc. latency per region over last 24h").
  3. Prototype: build an aggregator or try Mixed queries in a Grafana panel. Prefer a minimal working prototype over perfect modeling.
  4. Optimize: move heavy joins to the aggregator, add caching, ensure auth tokens are secured and rotated.
  5. Template & version: export the panel JSON, add it to dashboards-as-code with variables and provisioning YAML for the target Grafana instance.
  6. Operationalize: monitor dashboard performance (slow queries), add alerts where KPIs cross thresholds, and schedule reviews with stakeholders.

Governance, reproducibility and sharing real value

External references are useful, but we add concrete value by delivering:

Plugins & tooling we recommend

Security & compliance considerations

Examples we can share (non-proprietary)

To provide practical value without exposing customer data, we can publish:

Appendix — quick configuration notes

1. Mixed datasource in Grafana

In a panel choose the Mixed datasource, then add queries where each query selects its datasource. Use the panel > Transformations to align series or use "Outer join" for tables. :contentReference[oaicite:8]{index=8}

2. Business Charts

Install from Grafana plugins catalog or by using the Grafana CLI (if self-hosted). Business Charts exposes a code editor for ECharts options and a visual editor to map data frames to the chart. Documentation and examples are on the plugin site (Volkov Labs). :contentReference[oaicite:9]{index=9}

3. Dashboards-as-code

Export your dashboard JSON (Dashboard settings → JSON model) and add provisioning YAML or use Terraform with the Grafana provider to deploy dashboards across environments.

How we can help (call-to-action)

At Observabilitrends we help teams move from “lots of graphs” to actionable dashboards that are trusted by both engineers and executives. We offer:

Contact us at our contact page or email info@observabilitrends.com for a free scoping call.

References: Grafana docs on datasources & transformations; Grafana best-practices; Volkov Labs Business Charts & Business Suite docs and plugin pages. :contentReference[oaicite:10]{index=10}