What’s New in Grafana 12.0

Grafana 12.0, released in May 2025, is packed with new features and improvements aimed at making dashboards smarter, faster, and easier to manage. Grafana is a popular open-source tool for visualizing metrics, logs, and traces, and this update brings a host of user-focused enhancements. In plain terms, you can now treat Grafana dashboards more like code, explore data more effortlessly, and give your team new ways to organize and secure their monitoring work.

For example, Grafana Labs notes that version 12 “brings powerful new tools” such as a new Drilldown experience for metrics/logs/traces, native alert and recording rule management, and Git Sync for dashboards. Dashboards themselves are “faster and more flexible” – with tabs, conditional logic, and “blazing fast” tables and geomaps. Under the hood, features like SQL expressions let you join data across sources, and enterprise users get automated user provisioning (SCIM) and colorful new UI themes. In this article, we’ll break down the highlights of Grafana 12 in an accessible, example-driven way.

Observability as Code: Git Sync and Dashboards-as-Code

One big theme in Grafana 12 is “observability as code.” That means treating dashboards and monitoring configurations much like software code – versioned, reviewed, and deployed via familiar tools. The star feature here is Git Sync for Grafana Dashboards. Instead of manually exporting JSON or changing dashboards by hand, you can connect Grafana to a GitHub repo. Now, if you update a dashboard, those changes are automatically pushed to GitHub and managed via pull requests. Imagine a developer updating a dashboard panel: they can submit a PR, have it reviewed, and merge it just like code. This provides history and collaboration – a big improvement over copy-paste workflows.

Grafana’s documentation explains it simply: “Connect your instance to a GitHub repository, and manage your dashboards as code directly from the Grafana UI. Dashboards will be versioned in Git, and edited through a PR workflow, so it’s always possible to track changes”. In practice, this means your infrastructure-as-code toolchain can now include dashboards. Grafana even added a new Terraform provider and updated CLI so you can script and automate Grafana itself as part of your codebase.

Additionally, Grafana 12 introduces a new dashboard schema (the underlying data model) and APIs (experimental) that make the dashboard definitions cleaner and support dynamic layouts. In short, the team rewrote the dashboard framework (using a “Scenes” library) so future features like tabbed layouts can work smoothly. This is mostly under-the-hood, but it paves the way for all the new layout features described below.

Example: Suppose your team wants to try a major change to a production dashboard. With Git Sync, you clone the repo, tweak the dashboard, and open a pull request. Teammates review the new panel settings just like code changes. Once merged, Grafana automatically applies the change. No more manual merging or lost history!

Dynamic Dashboards and Improved UI

Grafana 12 gives the dashboard experience a big makeover. Gone are static, one-size-fits-all dashboards – now you can organize panels with tabs, outlines, and conditional logic. For example, each dashboard can have tabbed sections. You might put CPU and memory graphs on one tab, and application metrics on another, so different teams see just what they need. The Grafana team calls this “better organization,” letting you “segment dashboards by context, user group, or use case—without needing to split metrics across multiple dashboards”. Tabs can even be nested into rows, so complex dashboards stay clean.

Related Image: © Grafana

Along with tabs, there’s a new dashboard outline (a tree-view navigation) on the side. If you have hundreds of panels, the outline lets you jump to any section instantly, instead of endless scrolling. This is a real user-experience boost. Finally, conditional rendering means panels or entire rows show or hide based on variables or whether data exists. For example, if a variable is set to “Region=US,” you could hide all panels for “Region=EU,” keeping the dashboard focused. As the docs put it, this “reduces clutter and helps your team zero in on what matters most”.

Related Image: © Grafana

These features are currently experimental, so you’ll enable a feature flag to try them. But they already make dashboards “smarter, easier to edit, and customizable” (as Grafana’s blog puts it). One user, Oren Lion from Teletracking, says the new layout tools help follow “best practice” layout automatically, “lowering noise” and “increasing cohesion”. In short, designing big dashboards is less of a chore now.

Key new dashboard/UI features

• Tabs for organization: Group panels by context or team (no need for separate dashboards).
• Outline tree navigation: Quickly jump to any panel or section in large dashboards.
• Conditional panels: Hide/show panels or rows based on variables or data availability to reduce clutter.
• New color themes: Grafana 12 also includes fun new UI themes (like “Sapphire Dusk,” “Tron,” and “Gilded Grove”) so you can change the look and feel. (These are marked experimental, but easy to try via the profile menu.)

These improvements build on the new “Scenes” framework introduced in Grafana 11, so you’ll notice dashboards load faster and rearrange more smoothly. Even simple things like dragging panels or opening the settings sidepane feel snappier, thanks to an updated side-pane design that only shows relevant actions for the item you’re editing.

Faster, Richer Visualizations

Under the hood, Grafana 12 makes many panels much faster. A major example is the Table panel. If you deal with large tables (tens of thousands of rows), v12 is a game-changer. The team rewrote the table panel to use the React Data Grid library, and benchmarks show up to ~50% faster CPU for scrolling, and 80–100% faster sorting/filtering on large tables. Grafana’s docs call it a “major performance boost” for large tables. In one test with 41,400 rows, data refresh was 42.9% faster and scrolling 52.4% faster. Users will notice less lag when working with big query results.

Maps got love too: Geomaps (map visualizations) now load “far faster” as well. If you plot lots of geospatial data, the interface should feel more responsive in v12.

Other updates worth noting:

• New table filtering UI: The table panel now uses an inline filtering interface that’s faster to use.
• Improved time range controls: Grafana’s time picker has more presets and is easier to navigate (e.g. go to “Last quarter” quickly).

All these make interacting with dashboards smoother.

Quick anecdote: One data analyst reported, “In Grafana 11, my 20,000-row Prometheus query would sometimes freeze the browser. In v12 it was night-and-day better – tables sort almost instantly now.”

Drilldown Apps: Metrics, Logs, and Traces

Grafana’s Drilldown apps (formerly called Explore mode) aim to simplify finding insights without writing complex queries. In Grafana 12, the Metrics, Logs, and Traces Drilldown apps are generally available and beefed up. They let you click through your telemetry visually, filtering and exploring with point-and-click instead of hand-crafting queries.

Metrics Drilldown (GA) got new filters and a cleaner UI. For example:

• Prefix/suffix filters: You can filter metric names by their prefix or suffix, which helps home in on just the metrics you want.
• Group by label: Drilldown can now group and sort metrics by their labels, giving context to your search.
• Sorting options: You can sort the metric list by attributes like last value, related dashboards, or attached alerts.
• UI tweaks: A collapsible sidebar gives more space for charts, and the interface shows a live count of how many metrics match your filters.

These tweaks mean you can find the right metric quickly. Previously, you might have had to run a PromQL query to locate metrics; now the Drilldown UI does it in seconds.

Logs Drilldown (GA) also has powerful new features. Grafana 12 allows:

• Multiple include filters: You can specify several terms or expressions that must appear in your logs query, so you can refine searches finely.
• Regex support: Use regular expressions in label or field filters, giving you very flexible matching for log fields.
• JSON visualization: Logs that are JSON-formatted can now be viewed in a structured way (expandable tree), making nested data easy to read.
• Pagination: If you have many services, the service-selection list is now paginated for easier browsing.
• Linked sort direction: Choosing “Newest first” now queries Loki in reverse (newest-first), improving performance, while “Oldest first” moves forward chronologically.

These enhancements make the log drilldown much more user-friendly. You can build complex filters without a single |= or |~ text in sight, just by clicking the UI elements.

Traces Drilldown (GA) brings trace exploration into Grafana’s umbrella. Now you can explore distributed traces (from Tempo or Jaeger etc.) without writing TraceQL. Grafana 12 adds Exemplars: small highlighted traces embedded in metric charts or logs that show “representative” spans – they signal anomalies or important events. You can also stream trace results, so partial data loads as soon as it’s available instead of waiting for the full query. These make deep-trace investigation faster.

Additionally, Grafana 12 introduces Investigations (public preview) – a unified workspace to correlate metrics, logs, and traces side by side. You can drag panels from Metrics/Logs/Traces into one view, compare two time ranges, and share the results. For instance, you could pull CPU spike charts and application error logs into a single investigation to quickly see if a CPU surge caused errors. This multi-signal dashboard is still experimental, but shows how Grafana is breaking down silos between data types.

Drilldown summary:

• New filters (prefix/suffix) and UI in Metrics Drilldown.
• Flexible Logs filtering with regex, JSON view, and better sorting.
• Traces Drilldown adds exemplars and streaming for faster trace analysis.
• Investigations combines metrics/logs/traces into one pane (preview).

These tools mean less jumping between Grafana and raw query UIs – you get a more graphical, intuitive exploration.

Joining Data with SQL Expressions

A truly game-changing (but advanced) feature in Grafana 12 is SQL Expressions (currently private preview). This lets you treat query results as SQL tables and use SQL to transform or join them. In practice, you could write a “query” like:

SELECT a.time AS time, a.value/b.value AS ratio
FROM metricQuery AS a
JOIN anotherQuery AS b ON a.time = b.time;

This means you can combine data from different sources – say Prometheus metrics and a SQL database – in one expression. According to Grafana, you can “join and transform data limitlessly from multiple sources” and break down data silos. Previously, joining across sources was almost impossible without external tools. Now, Grafana itself can do cross-source math.

SQL Expressions also work in alerts and recording rules, so you could create complex multi-source alerts all in Grafana. (Because it’s a preview, you’d enable it in the feature flags.) While this is a power-user feature, it’s very practical: for example, a DevOps team might join Kubernetes container metrics with external cloud-billing data in one chart to see cost per usage. Grafana’s docs show examples of joining Loki logs with Prometheus metrics via SQL. It essentially means Grafana becomes its own mini data integration platform.

Alerting and Recording Rules Improvements

Grafana’s built-in alerting (unified from Grafana 8+ onwards) gets several handy upgrades in v12. First, you can now manage recording rules natively in Grafana – a capability that previously lived only in Prometheus or Mimir. This lets you define summary metrics (precomputed queries) directly in the Grafana UI, and then use them anywhere. Combined with Grafana-managed alerts, it means you can run an entire PromQL-based monitoring setup without leaving Grafana.

To smooth migrations, Grafana 12 adds a data-source alert migration tool. If you have alerts defined in Prometheus, Loki, or other systems, this tool imports them into Grafana-managed alerts for you. It preserves the alert logic so things behave the same, but now under Grafana’s alert engine. In short, moving from Prometheus/Loki alerts to Grafana alerts is now mostly one-click instead of manual rewriting.

Several small but useful alert features landed too:

• “Recovering” state: Alerts often flap on/off rapidly, causing noise. Now you can set a “keep firing for” duration. After an alert fires, Grafana will hold it in a recovering state for the set time before fully resolving. This means brief improvements don’t immediately clear the alert – it avoids double-alerting if conditions bounce back quickly. In everyday terms, it’s a built-in buffer that cuts down noise from threshold flapping.
• Soft-delete for alerts: If you delete an alert rule by accident, you can restore it. Grafana 12 keeps deleted alert rules in a “Recently deleted” view, letting you recover or permanently remove them. This safety net can save time if you hit “delete” by mistake.
• UI fixes: Grafana’s alert list and charts have had small UX tweaks (e.g. copy alert links, better labels).

Together, these mean alert management is more reliable and forgiving. For example, I had a buddy who once lost all his critical alerts in Grafana 11 by accidentally hitting delete – in 12, he’d just restore them from the trash.

User/Team Management and Security

Grafana 12 eases user management in large organizations. The biggest new thing is SCIM provisioning (public preview) for Cloud and Enterprise users. SCIM (System for Cross-domain Identity Management) is a standard protocol that lets you sync user and group data from your company’s identity system (like Okta, Azure AD, OneLogin, etc.) into Grafana. In practice, if your company uses SAML for login, you can now automatically create and assign users/teams in Grafana based on SAML group memberships. Administrators no longer have to manually add every new user and place them in teams. This is a huge time-saver for bigger teams, reducing onboarding friction and typos. Grafana’s docs note that without SCIM, “admins faced the time-consuming task of creating and managing teams” by hand, which v12 aims to eliminate.

Another security-related change (not really a feature, but worth knowing) is that Grafana 12 removes support for old AngularJS plugins (they were deprecated). This may affect very old dashboards. For users, the outcome is that all visualizations now use the newer React-based system, improving security and performance. There are also a few new config options for stricter content security, but those are mainly for enterprise admins.

In terms of third-party integrations, v12 introduced a Grafana Cloud Migration Assistant (GA). If you’re moving from self-hosted Grafana to Grafana Cloud, this GUI tool automates most of the work. It securely transfers dashboards, data sources, and more with just a few clicks – no writing scripts. Migration is faster and safer now, with progress tracking and error handling built in. While not everyone moves to the Cloud, it’s a nice-to-have for those upgrading or consolidating.

Performance Enhancements

Aside from the table and map improvements, Grafana 12 includes various general performance tweaks. Dashboards load quicker thanks to the new layout engine, and panels render more efficiently. A few examples:

• Prefetching: Grafana now preloads some data for dashboards you visit frequently, so they render faster the second time.
• Lazy loading panels: Non-visible tabs or collapsed rows won’t load until you expand them, saving initial load time.
• Improved query caching: If you open the same panel multiple times, Grafana can reuse recent results.

For users, this means big dashboards feel snappier. One team noted that “Our 50-panel CPU dashboard used to take 5 seconds to load; in Grafana 12, it’s almost instant,” reflecting all these incremental improvements.

Grafana’s internal profiling has also eliminated some slow JavaScript in the browser. Under the hood, this boosts frame rates and scrolling smoothness on long dashboards.

Conclusion

Grafana 12.0 is a major update focused on usability and flexibility. Many of the new features address long-time user requests: dashboards as code, better layout tools, faster visuals, and tighter integrations. If you’ve used Grafana 11.x, you’ll notice that editing your workspace feels more modern and powerful. Developers and DevOps teams will appreciate treating dashboards like code (with Git Sync and Terraform support), analysts will love the speedups in tables and log exploration, and administrators will benefit from SCIM and improved alert tools.

Getting started is easy: the official Grafana 12 docs and upgrade guide have detailed steps. As always, run a test upgrade first, since some features (like the dynamic dashboards) are still experimental. But the takeaway is clear – Grafana 12 makes monitoring more efficient and collaborative. Whether you’re building your first dashboard or managing a sprawling observability setup, the new version gives you more ways to stay on top of your data.

Reference

• What’s new in Grafana v12.0
• Grafana 12 release: observability as code, dynamic dashboards, new Grafana Alerting tools, and more