Grafana 13 deep dive

It wouldn’t be GrafanaCON without a major Grafana release. In this session, Grafana team members walk you through Grafana 13 and the most impactful improvements across the platform.

Hear about how Grafana is becoming easier and safer to operate as production infrastructure, with updates that improve configuration management, recovery, and long-term maintainability. The session also showcases significant advances in core user workflows, including more flexible and powerful dashboards, with improved performance.

This session brings together the product and engineering work behind the release and shows how Grafana continues to evolve to meet the needs of the community, reducing friction in everyday use and helping teams get to insights from their data faster, even as systems grow in scale and complexity.

Alexa Vargas Ortega (00:00:02):

Bon dia, buenos dias and good morning, Barcelona. Good morning. I have spent the last five years working in dashboards at Grafana across different teams, and you cannot imagine how exciting it is for me to be here today and just share with you all of the amazing things that we have built for Grafana 13. In this version, we focus on the most challenging problems that many of you have faced. How do you build valuable dashboards faster? How do you work with dashboards at scale? How do you operate Grafana in a predictable and maintainable way? And of course, we also kept investing in plugins and the wider Grafana ecosystem. That flexibility makes Grafana work with so many different setups.

(00:01:00):

I am Alexa. I work as a staff software engineer at the Grafana sharing squad, and today we are going to go deeper into this version. So, let's begin. I want to start first with a story. Imagine yourself a year ago. It's Friday, 5:00PM, you are ready to log off, and then you hear a ring. It's your manager. Hey, OP, can you share the operational dashboard for the new payment service? We have an on-call rotor on Monday. You forgot. That dashboard doesn't exist. You have metrics in a Prometheus instance. Fortunately, your payment service is running in Kubernetes, so you have the metrics, but the dashboard doesn't exist. So, you go to Grafana, click build new dashboard, and then you see this. The blank, empty page.

(00:02:11):

This page can be a problem, and depending on how comfortable you are with Grafana, with your data, you can feel it, let's say, in different levels of stress. You know what you want, but you don't know where to start. So, today, my goal is to walk you from that blank, empty page into building valuable dashboards faster. How am I going to do that? First, we are going to define what we mean by valuable dashboards. Second, because we are in 2026, we are going to use a time traveling machine. We are also going to look how does it look like to work with a brilliant teammate, and I want to share with you three new initiatives that we implemented in Grafana 13. Across all of the demos, we are going to see many cool things that many of my teammates have created for all of you.

(00:03:14):

So, let's begin by talking about what do we mean by valuable dashboards. In the screen, you can see one of the coolest dashboards that I ever saw. It's by Ruben Fernandez. This dashboard is very valuable for him because it's built on top of three pillars. First of all, anyone in this room, without asking, without guessing, you know what is happening in this dashboard. It's very easy to read. It is also answering a specific question. How should Ruben commute today? And if you pay close attention to each of the panels, you could also see that each panel has a purpose. Creating dashboards like this is not an easy task. And, in fact, last year, we saw a lot of teams struggling building dashboards that were valuable for them.

(00:04:11):

So, let's go back to our requirements. We need a dashboard fast. Because I was telling you we have a time traveling machine, I actually would like to each one of you ask this question. How would you create that operational dashboard a year ago? In my reality, I have three options. I could ask a master of dashboards. Frequently, there is one in each organization. It's a favor, right? I could also spend the whole weekend trying to get familiar with my data in the explore page, or I could go into the community route and just even ask what is an operational dashboard and what kind of metrics should I put there.

(00:05:01):

And you might say, Alexa, that's a very 2025 problem. In 2026, we have Grafana Assistant. It will solve everything. Well, I actually agree. Assistant is one of the options that you could use. However, I would argue that you could also experience the blank page with Grafana Assistant. You even need to know how to ask the right question. So, for this reason, we decided to invest in three new initiatives. Suggested dashboards, dashboard templates, org-defined templates, and across all of these new initiatives, we also implemented many cool features. Safe queries, visualization suggestions, and many others that we are going to see through the demo. So, let's begin by starting with suggested dashboards. For our operational dashboards, actually, this feature is quite cool. We decided that the wisdom of the community should live inside Grafana natively. And we also added extra batteries on top, like integration with Assistant and a compatibility check that I will talk a little bit later in the demo.

(00:06:27):

So, let me show you how today you could create an operational dashboard using suggested dashboards.

(00:06:36):

And I first need to unblock my computer. Great. First of all, we are going to start in the data source list page. The Prometheus instance that has our data is the Grafana Cloud Learn prompt data. So, we are now having a new option called From suggestions. When we click this option, we are seeing the list of... we are seeing more things. We will be seeing the list of the most popular dashboards that we have. I think the demo bots are messing up with me today. Let's see. Yeah. So, here we are seeing the most popular dashboards that we have specifically for Prometheus instance. Because the suggestions are based on the data source type that each one of you is using. Because our service is running in Kubernetes, I actually want to use a Kubernetes dashboard. I am interested in the pods because our payment service is running in a pod.

(00:07:53):

So, first, let me share with you a little of the extra batteries on top. The compatibility score is a check that you can do in this suggested dashboards that are coming from the community and plugin developers to know how much overlap this dashboard has with the data source. It's answering a specific question. Will this dashboard work with my data source? So, it's really powerful. Let's just start by viewing this dashboard. And there is an error here. Demo bots, thank you. So, let's first select the data source that I am interested in. The pod that I am interested in is the payment service. So, let's just filter this out. And then we should see data. And a lot of errors. Alright. So, first of all, what do we have here? This dashboard was created by the community. Because our data is matching with the metrics that they were requesting, we already get some quick information of how our service is doing.

(00:09:07):

The cool thing is you don't need to pollute your instance trying different dashboards. Because this is not automatically imported into Grafana. So, what you could do is if the dashboard doesn't work for you, you can always use a different one. In this case, actually, this dashboard worked for us. So, let me save it and I can show you more things. So, this is for our payment service.

(00:09:46):

Yes. We are waiting. Thank you. So, now, with this specific dashboard, what is happening is we have a starting point. Someone else took the job of creating this dashboard for us and now our work is to tailor to the needs of our organization. So, we wanted to make it better for our manager. One of the first things that I always do is I like to explore how this dashboard was built. So, for instance, I am not a PromQL expert. But I always try to see first how this query is constructed, and then maybe I can reuse it. If I find the query interesting, I always have the option to use safe queries and just reuse it in the future. So, for instance, I can actually say, okay, this is a mem usage limit request. And let's just save it. And here we have many other queries that we could always reuse in the future.

(00:10:59):

There is also something new that maybe many of you didn't have the opportunity to see because it's in private preview, and it's the new query editor experience. The team spent a lot of time trying to make this cleaner. Like you can now have an overview of all of the queries, transformations, and creating queries is actually smoother today with this.

(00:11:25):

Now, let's just save this dashboard. And with these three clicks, actually I have a starting point. And what I will do is I will share this with my manager, and on Monday, I can just tailor this dashboard for our organization. The heavy work is done. And I can just remove things or adapt it better for us. Alright, so let's go back to the presentation. So, great. We have our operational dashboard. Our manager is happy. But then a few days later, a new request comes. This time it's coming from our CTO. He's asking if we can create a dashboard that can give us an overall overview of our platform health. Here we have a different kind of blank page. First of all, we know our service is running correctly. But we are asking here about health. Is it healthy? Not. And also, one of the requests that they mentioned is, it needs to be easy to read.

(00:12:47):

Remember the three pillars? It needs to make sense for everyone. And for that reason, we decided to invest in dashboard templates. Dashboard templates are common methodology templates that at Grafana we are offering to you. You can see them as a floor plan and then you just decide what goes in each of the rooms that we define for you. This also added some extra batteries like Grafana assistant. And I want to share with you how we could create that overall health view with this specific feature. So, let's go back to our demo again.

(00:13:37):

Yes. So, we are going to start from the quick add button. You will see a new option. Use template. And as I mentioned, we are offering you five different templates that are based on industry standards. We have DORA, Northstar, USE framework. But I am interested actually in the service health. So, what we could do is because this is data source agnostic and I don't want to do all of the heavy work, is use our brilliant teammate Grafana Assistant. So, if you customize with assistant, what assistant will do is first of all is going to take a look at the template and the structure of the template. Then it will take a look at your instance and it will see which data source actually can work with this specific template. It's doing a lot of things and hopefully it will offer me the data sources that I can use.

(00:14:39):

In this case, we have our metrics in this specific data source. So, if I click here, the heavy start work begins. So, what the assistant is going to do is it's going to go deeper into the data source. It's going to check, hey, do we have metrics that are related with traffic, error rate, saturation? And then what it will do is it will replace this template with real data. This can take up to five or six minutes depending on your data source. This is kind of like a big data source. And I find it really cool because you like all of the heavy work is done first by you and then you could always tailor it. Because we don't have five or six minutes in this presentation to just look at assistant working, I already did that beforehand. So, I click in the customize with assistant, and if I show you what it did is, again, it was asking me for the data source and then it did a lot of things. At the end, it gave me a dashboard.

(00:15:44):

So, the same as suggested dashboard, this dashboard is not automatically saved. So, you can iterate it over. You can discard it. But in our case, I find it valuable. So, let's just save this, g13, and this is our health system. And here, yeah.

(00:16:17):

So, what this dashboard is going to provide us is first a quick start to tailor it for our use case. We can always even like share this dashboard with our CTO. And the reason why is because it's preserving the structure of the template. So, you don't have to think where to locate it. Or how to organize it, actually. One thing that I found really cool from the features that we implemented is the visualization suggestions. So, let's say that I don't want to use our stat panel. I don't know about you, but for me, it's always really hard to know which visualization will look good with my data and actually will work with my data. So, if you press here, the change, what we get is the suggestions of different visualizations that can work with our dashboard. I am in love with the gauge visualization because it looks futuristic.

(00:17:18):

So, what I can do is I can just change it to gauge, and it's automatically adapting everything. Another thing that was also added into this feature is the panel styles. This is quite cool because sometimes the configuration can be a bit complex. So, for instance, I actually want the super futuristic one. So, let's just keep it like this.

(00:17:49):

What I will do in a real case is I will tailor this as much as I want. I will change it for our organization and try to follow the same patterns, the same colors, et cetera. Now, let's imagine that we become really good at dashboards. But we work in a big organization and consistency is key. It's critical, actually. We should be able to read the same kind of dashboards in the same way. So, when this happens, you need to think in build once, reuse multiple times. And for that, we are actively working in something that we call org defined templates. This is coming soon as an experimental feature. And today, I wanted to give you a sneak peek with my local house branch and see what you think about it. So, I have here a dashboard that I have iterated. It can work as a starting point.

(00:18:47):

So, what you will do is the dashboard looks great. Let's just save it as a template.

(00:18:55):

I will say, well, this is my amazing G13 template. We can generate a thumbnail, but I will not do that right now. And then when the template is saved, it's available for the whole organization. One cool thing is it's going to support RBAC, so, you can define for different teams which templates make sense for them. Then you will have an available template gallery with all of the templates that we have created, and we should have here the amazing G13 card system template. I like to always generate the thumbnails, but time. So, I will not do that here.

(00:19:39):

Perfect. Let's go back to our presentation to do a small recap of what we did today. So, we started with a problem, a blank page, a, okay, what should I do now? And we are ending with three new alternatives that you can consider for solving these problems. Suggested dashboards are really great when you want to take first inspiration from the community, when you also want to use battle tested dashboards, because this dashboard has been used a lot. And they are now natively integrated into Grafana, and that's powerful. We also have dashboard templates when you want to bring consistency across all of your organization and following some common methodologies. And if you are into a larger organization and you want to just build once and reuse multiple times, all defined templates will be there soon. So, if you ever face that blank page, or if you see your colleagues who are starting the Grafana journey facing that page again, I really hope that you now have an idea of where to start.

(00:20:56):

And now, I actually would like to invite to the stage to Dominik and Bogdan. They will talk to you about working with dashboards at SK. Thank you so much.

Dominik Prokop (00:21:19):

Hello, everyone. My name is Dominik. I'm a principal engineer at Grafana Labs.

Bogdan Matei (00:21:27):

And I'm Bogdan. I'm a staff engineer at Grafana Labs.

Dominik Prokop (00:21:30):

On a daily basis, both of us are working on teams that focus on evolving Grafana dashboarding experiences. Today, we're in a slightly different role. So, let me paint you a picture. Imagine you're a platform engineer at a large e-commerce company. You and your team are responsible for managing the entire Kubernetes infrastructure for your organization. The checkout service, recommendation services, all of the internal tooling. Over 200 engineers deploy to the clusters that you own on a daily basis, multiple times a day. I guess this is familiar to many of you. The responsibility of your team is also to build Grafana dashboards, so that people at the organization can understand what's going on with the systems. So, sales is watching revenue. Marketing is watching conversion funnels. System engineers are watching the system health. But the problem is that they are not looking at the same dashboard many times, right?

(00:22:26):

You maintain three separate dashboards that are essentially supposed to observe the same platform. And why is that? Because the audiences and the expectations of those are completely different. So, this is the type of problem that we set out to solve over the last year. We focused on four things that became our guiding principles. First, we wanted to help you focus on what matters. When you're investigating an issue, we believe that the dashboard should give you the answer rather than force you to open three or four more dashboards to get one, right? Second, helping you to navigate easily. When your organization grows and you have hundreds, thousands, or ten thousands of dashboards, finding an answer to your question should never feel like a guesswork. Third, helping you to build faster. Meaning, less time spent pixel pushing, making your dashboard perfect, less time repeating the same queries over and over again.

(00:23:23):

And fourth, helping you to maintain less, 'cause it's natural that fewer dashboards is a less chance of drift and data duplication. So, let me show you what this could look like in real life. Remember, you're a platform engineer at an eCommerce company. Imagine that Black Friday is just around the corner and a colleague of yours is asking to add a region breakdown to the dashboards.

(00:23:49):

Maintaining multiple dashboards for those audiences probably means that you need a new variable to all of those dashboards. As a consequence of that, you need to update multiple queries, right? So, this is a lot of effort that you need to put in to address such a simple ask. But the real cost shows up during the Black Friday itself. Sales is watching one dashboard, marketing is usually looking at a different one, and engineers is watching theirs. Traffic is surging, orders are spiking, latency is creeping up. But none of these teams can really see what others are seeing. They're jumping between the dashboards, copying links, pasting them on Slack, asking questions like, are you seeing this too? So, it's three themes, a critical event during the year, and very limited shared context. Let us show you how we think dynamic dashboards that we are introducing in Grafana 13 will help in scenarios like this.

(00:24:54):

Let's switch to the demo and Bogdan, let's show them.

Bogdan Matei (00:24:58):

Yep. Let's see. Okay. So, Dominik just walked through some of the struggles that some of you are facing in their day-to-day engineering life. So, this is the control room. All the dashboards that Dominik mentioned, they're here as tabs. This means we merged multiple dashboards together into only one dashboard. And because it's that easy, we also added a new one, an executive one and this is because people are working from various tabs. For example, VPs are working from the executive tab, sales work from sales, and on-call engineers do go to engineering. Before we go further, I want to make a small note. This is not necessarily the way to create dashboards. This is one use case. So, the use case of some of you might fit this, but for other use cases, it's just better to leave your dashboards as standalone dashboards. So, do be very careful and analyze how you want to build the dashboards.

(00:26:04):

But now let's continue with the demo. So, as I mentioned, this is one dashboard. This means one URL, one bookmark. During an incident, you start from a shared context. You get the URL, you share it with your peers, you have the same filters, you have the same time range. You don't have to leave the context.

(00:26:30):

Now, let's remember the ask that started all this. Add a regional breakdown. Well, if we look up here, we can see that we have a bar. This is a filters bar. Once you select Europe as a region, you just click it, you set Europe, and that's it. The filters are automatically applied to your entire dashboard, to your tabs, to your panels, to your rows, everywhere. So, they are all here. And you can either use the top bar or you can use the pane in the sidebar. It's up to you how you want to use this. But here's the flip side. Sometimes you don't want variables to apply to your entire dashboard, right? And, for example, engineering needs namespace, needs pods, but sales and marketing don't need those. This is why we introduced section level variables. This means that you can define variables at tab level, at row level, and they are gonna be applied only to that small container, to that small group.

(00:27:40):

They are not gonna pollute your entire dashboard. So, what does this mean? Well, if you use dashboards, this means that the filtering experience can be way, way neater. You don't have to juggle with five variables and so on and so forth. You have one filters bar, and that's about it. But if you edit dashboards, if you create dashboards, well, here's how filters actually come into play. We can see that we have multiple filters. But if I go to one of the panels, we can see that the filters are not here. And that is because you don't need to modify your queries for the filters to be applied. They are injected automatically, so you don't have to do the same repetition of editing queries and so on multiple times. And if we look at the engineering dashboard, we can see that this has like, I don't know, 25 panels.

(00:28:40):

So, yeah. Now, we started grouping multiple dashboards. We sorted filters. But somebody actually had to build this dashboard. Some of you may know how to create a dashboard. Like, you drag a panel and you resize it. You adapt to the panel next to it and so on and so forth. Well, that can be a tedious work at times. For example, let's look at this top row. Well, in Grafana 13, we introduced something called auto grid. And by auto grid, you set some constraints, how wide, how tall, and how many panels you want to be on the same row. And the panels are arranged automatically. So, you don't have to resize them manually. If you resize your screen, the panels are way more responsive. It adapts to your screen. And that means faster time to build dashboards and a better experience to view dashboards. But you may say, Bogdan, you merge multiple dashboards.

(00:29:46):

How is the navigation? Ain't that cumbersome to use? No. Because in Grafana 13, we brought content outline, which is a table of contents for your dashboard, I mean, executive. I go to engineering, I click on engineering and I can jump wherever I want in my dashboard.

(00:30:07):

For editors, this is even better because you don't only have access to rows, tabs and panels, you also have access to variables, to annotations, to links and so on and so forth. And if you select one element, for example, you go to edit mode directly of that specific element while being in edit mode for the dashboard. So that means way faster ways to edit your elements. You don't have to do scrolling, you don't have to do searching, nothing like that. You just access everything in a central place. Some of you might remember that last year we called all those features dynamic dashboards and you may ask, what's dynamic about it? I mean, until now everything is static, right? Well, some of you may also remember that last year we brought up show-hide rules. And show-hide rules, it's a super neat feature that allows you to hide elements in your dashboard.

(00:31:05):

That means tabs, rows, panels and you can set different criterias, like for example the time range, you can hide the panel depending if it has data or not, who wants to see a panel without data. You can hide elements based on variable values. How does that work? Well, I'm in engineering, I don't have any pod selected right here. I go on, I select a pod and suddenly my pod row appears. This means I can view the details of a specific pod right into my dashboard without having to leave my dashboard and go to another one, see the details, come back. So again, the share context, it's still here, it's still in one place. For the time being, I'm gonna hide this and I want to show you how all of this come together. I'm gonna move to executive, I'm gonna assume this is Black Friday and I'm gonna assume I'm watching the revenue.

(00:32:07):

I can see that there is a drop here. What might cause this? I'm gonna filter the time range a little bit, just so I see this better. We can see that the request per second did not drop. I'm going to marketing, I can see that we still have visitors. The conversion rates, even though they are dropping, this doesn't seem to be the problem, meaning that again, our campaigns are working fine. So if it's not marketing, it should be technical, right? And then I'm gonna go to engineering, as simple as that, without leaving my dashboard, I can go on, I can look at pod readiness, I can see that the checkout pods are failing. I'm gonna scroll a little bit. Service health summary shows me that indeed the checkout API and the payment workers, they do have issues.

(00:33:05):

And then I can go on, select one of my pods and there we go. The technical investigation can start right now. This is how you can go from business data to a technical investigation in a matter of seconds. So you don't have to do a lot of back and forth. You don't have to do a lot of scrolling. You don't have to do a lot of searching. You don't have to ask your colleagues, where is that dashboard? Because it's all here. Now, as the last thing I want to show you, I mentioned service health summary. I'm gonna go into edit mode for this specific panel because I want to show you something. You can see that this panel has three queries that are hidden and another one that's visible. This last one, it's SQL expressions. What does this mean? It means that because I'm familiar with SQL, and some of you might are, it allows me to use the results of the other queries, transform them using the syntax that you already know, joining, ordering, selecting, and so on and so forth.

(00:34:16):

And you can actually merge multiple results into only one using a familiar syntax. So we've seen how all these features are working together. Now I want to pass it back to Dominik to talk about how these features are actually fulfilling the goals that he presented in the beginning. Dom?

Dominik Prokop (00:34:41):

Yes, thank you Bogdan. Let's switch back to slides. What Bogdan presented is a lot, I know, but I hope you still remember those four guiding principles that I mentioned at the beginning. So with the show-hide rules, the panels only were shown when they were relevant for the users, when they picked up the correct bot, right? With the tab-level variables, only engineering had variables that were relevant for them. So each audience saw exactly what was important to them and nothing more. Even at this size of the dashboard, the content outline made it super easy to explore and navigate through it.

(00:35:29):

The sidebar inline editing that Bogdan showed, and especially the autogrid, made it super fast to build this dashboard and finally, three dashboards became one. So it's way less to maintain, those dashboards are always in sync and never out of date. And it's not a promise that we're making, it's something that's landing in Grafana 13. So you can go and try it out right after this talk. And of course, this didn't happen overnight, we spent many, many months working on this and we received plenty of feedback, both from our customers and you communities, I would like to take this moment to say thank you to all of you. A lot of the feedback that you provided us with is actually in the product. But there was one thing that during those months kept coming back over and over again, and that was a question, does it work with Assistant?

(00:36:23):

And we're happy to say that yes, Grafana Assistant is fully capable of interacting with dynamic dashboards, both in the edit mode and in the view mode. Literally, Grafana Assistant is capable of performing the same actions as a human being. And this is built on an API, on a contract between Assistant and Dashboarding. And this contract will naturally evolve together with the new features that we will be adding to Grafana Dashboarding in the future. And everything that you saw today is backed up by the new Dashboards API. If you were in Seattle last year, we have introduced the Dashboards API v2 as experimental, but today I'm happy to say that we are announcing Grafana v2 API as generally available in Grafana 13. It's a modern, schematized, standardized, and versioned API that you can use from Grafana UI, of course. You can use it with Assistant,

(00:37:27):

you can use it with the new Grafana Cloud CLI gcx, that we were talking about yesterday.

(00:37:35):

You don't have to click around in the UI, literally. You can manage your dashboards as code using Terraform. You can manage your dashboards directly through the API, through Git Sync. It's up to you. The thing is that the v2 Dashboards API, is the recommended way going forward for the as code use cases. And at the heart of this new API is the new Dashboard schema. Again, last year it was introduced as an experimental one, now it's generally available. It's a completely new model that represents Grafana dashboards. It's built with future in mind. It's redesigned from the ground up. Panels are separated from layout, which enabled us to introduce new layouts into Grafana. The building blocks, like variables, like annotations, panel options, they're all well-typed, intuitively scoped, and the whole structure follows the Kubernetes resource model. So it's standardized, it's predictable, and it's built with automation in mind.

Bogdan Matei (00:38:42):

Alrighty, this was a lot. We saw dynamic dashboards, we saw Grafana Assistant and integration with dashboards, we saw the Dashboards API v2, we saw the v2 schema for dashboards. This was a lot. I'm pretty sure that these features are gonna make your life easier. And I want to invite you to go try it out, and if you have any questions, do look for us, we are gonna be around the venue. Come talk to us. We are super eager to talk to you about these features. And this was dashboards at scale. And now I would like to invite Artur and Stephanie to talk about operating Grafana at scale. Thanks. Thank you so much.

Stephanie Hingtgen (00:39:40):

Hello, hello. I am Stephanie, and I'm a Principal Software Engineer at Grafana Labs.

Artur Wierzbicki (00:39:44):

And I'm Artur, and I work as an Engineering Manager at Grafana Labs. So as we've just seen, dashboards themselves are evolving to work better at scale. But many of you aren't just building dashboards, you are also operating Grafana for the rest of your organization. And your teams then depend on Grafana for monitoring, for alerting, and for incident response, which makes Grafana itself part of the critical infrastructure. And in Grafana 13, we've also focused on making Grafana easier to run and manage so admins can spend less time setting everything up, firefighting, and more time building. As you know, Grafana is a really flexible platform. It has been used for almost everything from monitoring the lunar landing, all the way to supporting the operations of one of the world's largest online food delivery platforms. And that flexibility lets you shape the platform around your own workflows and processes, but that flexibility also can come with some costs.

(00:40:48):

Once you start onboarding hundreds or thousands, or in some cases even tens of thousands of engineers, that flexibility can quickly turn into lots of operational overhead.

(00:41:01):

So once Grafana reaches a certain scale, some problems start appearing just more and more. Data sources get misconfigured, unaudited changes get in, and dashboards mysteriously disappear. And with lots of engineers relying on Grafana every single day, all those issues can quickly turn into days worth of work for you, the admin. And we know this problem really well, we are using Grafana internally to monitor over 30 cloud regions of Grafana Cloud, and we've heard very similar stories from many of our largest customers. We took everything we've learned and we incorporated all of that right back into the product so that you don't have to relearn all those lessons all by yourself. So we are keeping the flexibility that's important for us, we're just giving admins better defaults and clearer paths. And well, I've been talking a lot about the admin today, so how about we take a look at what their day actually looks like?

Stephanie Hingtgen (00:41:57):

Yeah, definitely. So as a Grafana admin for a large organization, your day rarely starts with building dashboards. Instead, it starts with requests. Typically some Slack messages coming in asking for help with their dashboards, or teams asking how to best organize their dashboards and folders and add new team members, or support tickets coming in asking to set up their as code. So let's walk through an example day of a Grafana admin. Your first message comes in, and it's from someone who accidentally deleted their dashboard, and they had spent hours curating that perfect dashboard, and they're hoping that you could help them restore it. Well, previously, this meant that you needed to download a Grafana database backup, dig through the dashboard table, find the dashboard JSON, and then manually restore it, and that worked, but it takes time, and that time can add up, particularly in larger setups.

(00:42:54):

So in Grafana 13, we introduced native dashboard restore, which allows you to restore your dashboards directly in the UI. And users can do that without having to ping any Grafana admins. So let's switch to the demos and take a look at how it works.

Artur Wierzbicki (00:43:12):

Alright, I'm in my beautiful, light-themed Grafana, because I'm one of those people. I have some folders... and thank you. And I will try to delete one of the dashboards. I will press delete, then I will type delete, and again, press delete. Now the dashboard is gone, mysteriously. And I can go to the new recently deleted tab, click on the dashboard. That list also shows me just a list of all of the recently deleted dashboards. Press restore, pick the folder to restore to, click restore, and yeah, it's right here. Now, that feature was built with extensibility in mind. So right now, it's just dashboards, but in the future, we will definitely support more resources like alerts and folders. And yeah, this is all so that you can restore all of your resources without your admin having to do any database digging.

Stephanie Hingtgen (00:44:15):

Amazing. Yeah, so once you've restored that dashboard, the next message that comes in is from someone who actually didn't change their dashboard at all. And they logged in this morning, they opened their dashboard, and then now the log panel isn't loading properly. And they went to explore, they tried that data source, and again, it wasn't loading. So they messaged you and asked if you could take a look. And previously, that meant you needed to dig through the Grafana logs, look if anything had changed in your data source config or any plugins had changed, and you were able to find the root cause. But again, that took time, and that time will add up in larger setups. So in Grafana 13, we GA, Grafana Advisor, which allows you to go into one centralized location and look at what might be going on in your Grafana instance.

(00:45:01):

So if any data source health checks are failing, any plugins need to be updated, or any plugin installs are missing. So let's take a look at what that does.

Artur Wierzbicki (00:45:09):

Alright, so I'm in Advisor. I see immediately that I have two actions highlighted by Advisor, and one of them is health check failed for one data source. And that's front-end log, so that matches the panel that was failing. So in Advisor, we have this action button that takes you either to the place where you can fix the issue, or the place where you can learn more about how to fix the issue. So I'll press this. In the configuration UI, I see that, well, the host is indeed wrong, so I will correct it to low key. I'll press save and test. Okay, it magically worked. So now back to Advisor, and I will rerun the checks, and that action is indeed gone. So one other interesting check in Advisor that will be, I'm sure, commonly used is the update check for plugins that lists all of the plugins that are out of date.

(00:46:03):

And again, with the action button, you can go to page where we can fix the issue. For all of the checks supported by Advisor, you can go to the configure page, and you can toggle the checks on and off, depending on what do you want to be supported by Advisor. Now, the one last thing in Advisor is the integration, the native integration of Assistant. So we have a button right here that lets you invoke Assistant, then Assistant is right there with you, and it walks you through what the check really means, and guides you through the troubleshooting process. That's it. What's the next thing in my day, Stephanie?

Stephanie Hingtgen (00:46:47):

Yeah, so the next message that you get is from some managers, and they have a new team member joining, and they wanna get them all set up in Grafana before they start their first day, so that they can hit the ground running. Well, previously that wasn't possible. The users had to log in to Grafana first for them to exist, and then you could add them to team folders or different things like IRM. Well, now with SCIM, which stands for, System for Cross-Domain Identity Management, your user and team management workflow will all be from your IDP. So as soon as the user or the team exists in your IDP, it'll sync to Grafana, and then they will exist. So let's see it in action.

Artur Wierzbicki (00:47:25):

Awesome. So let me navigate to the new configuration UI. So in Grafana 13, SCIM is now GA, and we've also added the configuration UI that lets you configure the SCIM provider if you don't want to use the configuration file. So to get started, I will enable the user sync and the group sync that lets SCIM provider sync both users and groups. And then, while we officially support Okta and Entra ID, I will be using an open source IDP called Authentic, which also supports the SCIM protocol. So open it in the split view. Alright. And in Authentic, we first have to create something called the SCIM provider. Let's click next. I will call it Grafana SCIM provider, and I will copy paste the URL from Grafana. I'll be using the token authentication mode, which means that Authentic will be using the Grafana service account token to push the changes back to Grafana.

(00:48:32):

So I will open the service account page. I'll type Authentic. I'll give it the admin role for the more purpose is to simplify things. Create a token. Okay, got the token. And that will be used by Authentic to push changes. Now, the last step is to pick the groups that I want to sync to Grafana and finish. Now, Authentic also requires me to create a corresponding application tied to the provider. So I'll just quickly do that. Grafana, tied to the provider, create. Okay, now back to providers, and I will run the initial sync. Let's pray it works. Waiting to run. Yeah, hopefully it will run. Back to users. And yeah, it did actually run, and now we see users from Authentic right there in your Grafana and we also see teams. So now I will test creating a new user in Authentic. So I'll go to groups. I'll go to the Grafana scheme users.

(00:49:38):

It has five members right now. I'll create a new user. I'll call it a grot, because every team deserves a grot. Create a user. I'll refresh. And yeah, it's six. And the grot is right here. So with SCIM, again, as an admin, you don't have to wait for the user to log in to finish their onboarding. As soon as you add the user in your IDP, they automatically get synced to Grafana.

Stephanie Hingtgen (00:50:09):

Amazing. Yeah, so once you have your users and teams in Grafana, the next question is, how can we best organize our team's dashboards and folders? Because in these larger setups, you can have thousands of dashboards and folders, and it can be really difficult to find your teammates' dashboards that perhaps you saw on an incident before, and it was super helpful. And so in Grafana 13, we introduced team folders, where you can assign ownership to a team folder, and then for everyone in the team, that will become their default folder to put dashboards or alert rules in. So let's see it in action.

Artur Wierzbicki (00:50:44):

Let's see it. So from SCIM, one of the teams that I synced was called Frontend Platform. So now I will go to the dashboards view and close Authentic. We don't need it anymore. And here we can see that one of the folders that we already have in the instance is called Frontend Platform, so it kind of matches with that team. So I will go to that folder, and in folder actions, I will select manage folder owner and pick the team, Frontend Platform, save owner. Okay, so now this folder is owned by this team. What does it mean? I can navigate to the team. I can take a look at all the folders managed by that team. But in general, a team folder is essentially a team's space in Grafana. It's a place where a team can have all their dashboards, alerts, folders with clearly defined ownership,

(00:51:37):

and the ownership piece here is key. It changes a few things, starting with how we surface those folders in Grafana. So now if I go to alert rules for, let's say, and I create a new alert rule, and I select the folder, as you can see, the team folders are shown right up here at the top. And in case of my user, I'm in an admin team, so it's the secret admin stuff that's shown up at the top. If I go to dashboards, and I create a new dashboard and save, the team folder is actually just pre-selected for me. And if I go to the dashboards view again, team folders are also right here in the top. So team folders make it easier for your teams to select the right place to store the resources and also discover the resources. And this feature is evolving, so please try it out and give us all the feedback about what would you like to see next.

Stephanie Hingtgen (00:52:36):

Amazing. Yeah, so team folders, in addition to SCIM, gives you a really clear ownership and organization within Grafana. So your next message that comes in is from some people who wanna set up their as code, and they wanna have auditing, versioning for their dashboards, but they wanna continue to build their dashboards in the UI, because that's what they're used to. Well, previously that wasn't possible. You either chose that you had as code for your dashboards, or you built it in the UI. Well, in Grafana 13, we're super excited to announce that GitSync is GA, and you can do both now. You can have your dashboards backed up by as code, and you can also build it in the UI. So let's see it in action.

Artur Wierzbicki (00:53:17):

Let's go. So I will go to the provisioning UI, and for the third time, I'll announce that GitSync is now GA and available everywhere. I'm super excited about this. And we also added enhanced support for GitHub and Bitbucket in enterprise and cloud, but also support for any Git server, whatever you want in OSS via the option called Pure Git. For GitHub though, specifically, we've also added support for authentication via a GitHub app, so that you can manage the credentials centrally without having to rely on personal access tokens from someone from your team. So let's test out the GitHub app connection. I will type the title. I will fill out the credentials for the GitHub app and create a connection. Now we automatically fetch the repositories that the GitHub app has access to. So next step, configure the repo. Now I will be using the main branch, and I will be using the path gcondemo for all of the resources on my main branch.

(00:54:32):

Then the report.path is empty, so there's nothing to sync back. And I will choose the title for the folder in Grafana, and settings. So I want to have the pull request option enabled, I want to be able to just push directly to main, and I also want to generate dashboard previous. Finish. And everything is green. Demos are going great so far. So back to dashboards view, I can see that this folder is here, and it's indeed empty. But to get started, I will navigate back to this dashboard that's now fixed, and I will save it as a copy in my git sync folder. And I'll push it directly to main to just get started quickly.

(00:55:25):

Alright, let me go here. Alright, it's been pushed to main. It's right here in the repo. Alright, now let me make some changes. So in the slow routes panel, I would want these two to be highlighted in yellow. So if the p59 latency is above 500, let's color it yellow. So let's scroll down right here, do 500. Okay, looks great. And this time around, I will save it to a new branch to test out the pull request workflow. And I will type description, latency color change, save. Okay, now I will be prompted to open the pull request on GitHub. So I will do that. I will create the pull request. And if like some complicated changes, I usually prefer to ask people who know better to take a look. So Stephanie, could you please take a look at the changes?

Stephanie Hingtgen (00:56:31):

For sure.

Artur Wierzbicki (00:56:33):

And in the meantime, I will take a look at the diff. And as you can see, 700, 500, and there is a link to view the source on GitHub, because it was the first change of a dashboard done in a Git Sync folder. So back to conversations. First, we see dashboard previews. So we see that before, green, after, yellow. And Stephanie, how did it look?

Stephanie Hingtgen (00:56:59):

Looks amazing. Approved.

Artur Wierzbicki (00:57:00):

Okay, awesome. Now I feel safe. Merge. Okay, so back to dashboards. Let's go to this dashboard. And yeah, the changes are synced automatically back to my Grafana. So two different workflows, push directly to main or open a pull request, depending on your risk appetite and organizational policies. But in the end, all your dashboards have full history in Git, they're version controlled. That's it for the demo.

Stephanie Hingtgen (00:57:29):

Amazing. Let's go back to the presentation. Awesome. So all of these features that you just saw, Restore Dashboard, Grafana Advisor, Team Folders, SCIM, Git Sync, all of these are so that the Grafana admin's life can be easier. But they weren't developed in silo. They were part of a broader shift in Grafana 13 to make it easier to run Grafana at scale. So in addition to these features, we also had some platform improvements, such as re-architecting our secrets management and also GA-ing our first versioned APIs. So let's start with secrets, because as soon as you start running Grafana, secrets are everywhere. They're a part of your data sources and your integrations, and now also a part of your repos. And so we re-architected secrets in Grafana 13 around a concept called keepers, and keepers are where your secrets will live. So in OSS, the default system keeper will be Grafana itself, and then in cloud and enterprise, you can define additional keepers, such as AWS secrets manager, and then from there, you can create a secret within AWS secrets manager and then reference it within Grafana.

(00:58:43):

And this also allows you to reuse those secrets throughout Grafana for multiple data sources or multiple repos. And it also gives you the ability to rotate easily your secrets through either our CLI, or if your secrets provider provides that, you can do it there as well. And then in addition, there's a UI with one centralized location where you can view all of your secrets and you can add different labels to them. You can define what parts of Grafana are even allowed to decrypt it, and you can also revoke different secrets. And this is GA and cloud with on-prem on the way, and it's currently backing Git Sync, K6, and synthetic monitoring, and then data sources will be next.

Artur Wierzbicki (00:59:23):

And another major improvement in Grafana 13 are the versioned APIs. We now provide schematized and versioned contracts for dashboards and folders with many, many more resources coming very soon, and this matters for two reasons. First, it makes the Grafana APIs easier to consume by both you and your agents, as you can now rely on those schematized contracts and predictable API behaviors. And second, it matters because it makes automation safer and a lot easier to maintain. We know that you write a lot of scripts against Grafana, so do we, and we also know that Grafana upgrades can be sometimes challenging because those upgrades can come with API changes and those API changes in turn can break some of your scripts. We've unfortunately experienced this also firsthand. And the newly built Grafana Cloud CLI GCX takes full advantage of the new version APIs. I highly recommend you to try it out, but otherwise you can still just continue writing your own scripts, but this time around without having to worry about your scripts being broken by Grafana upgrades.

Stephanie Hingtgen (01:00:30):

Amazing. So in Grafana 13, we've made it easier for Grafana admins to run Grafana at scale. You can recover quickly with native dashboard restores. You can fix issues proactively with Grafana Advisor. You can organize easily with team folders in SCIM, and you can operate safely with Git workflows. Plus, all of this is on stronger foundations with better control and consistency with our new secrets management and our versioned APIs. And all of this is so that Grafana admins can spend less time firefighting and more time building. So let's welcome to the stage, David, to talk about what you can do with that extra time. Thank you.

Artur Wierzbicki (01:01:07):

Thank you.

David Harris (01:01:14):

Yes, good morning, everybody. This is nearly through, so well done. So hi, my name is David. I'm part of the product team here at Grafana Labs. And today I am very excited to talk to you about extending Grafana to reach even more use cases and share some details about how we're enhancing the Big Tent. For those less familiar with the term, when we say the Big Tent, what we mean is the ability for you to use the tools which make sense for you without having to migrate your data. It's where different tools from different vendors built for entirely different use cases can all come together under the Big Tent. Now with Grafana 13, we're making the Big Tent bigger and better. You can get more of your data no matter what system it's on or what network it's in.

(01:02:05):

So since Grafana 12, we've added five new fairly diverse data sources, starting with Jenkins for monitoring CI. One of the things that I really like about this data source is that it includes bundled dashboards for visualizing DORA metrics. So continuing that theme of making it easier to get to value faster. And it can help you work around some of the quirks in the Jenkins API. Next, we have SolarWinds for network and infrastructure monitoring. And finally, IBM DB2, which is a relational database particularly popular with large financial institutions. Then we have two open source data sources. So firstly, we created a dedicated data source for the Azure Managed Service for Prometheus. And here we extracted some of the Azure specifics out of the vanilla Prometheus data source so that that can be truly vendor neutral, and the Azure one can really focus on that experience. And then we have Cube.

(01:03:07):

So Cube we announced as experimental at FOSDEM this year. And Cube's really interesting because it can act as a semantic layer over your data. So you can define like a company-wide way to calculate ARR. And then you can query it in a far simpler manner just using dimensions and measures rather than traditional SQL. And as such, it really excels for those business intelligence use cases.

(01:03:35):

As well as expanding what data sources you can connect to, we're giving you more options on how you connect to that data. So with Grafana Cloud's Private Data Source Connect, or PDC, it makes it really easy to connect to network-secured resources. With PDC, you deploy a very lightweight agent that creates a SOCKS5 SSH tunnel to our infrastructure, and then all queries are proxied securely that way. And what makes PDC really interesting for me is that, yes, it has helped some of our largest customers to make that move from on-premise to cloud. But it's seen a ton of adoption amongst our free tier users as well. And the reason for that is it's just a really easy way to connect something like a local Prometheus instance to Grafana Cloud. You don't have to think about how you're handling port forwarding or auth. It's just run a binary and you're done.

(01:04:31):

So you can end up with one less thing to maintain if you want to make that move to migrate to cloud, or you can adopt a hybrid approach. You can use both OSS and cloud when either makes sense for you.

(01:04:44):

Over the last year, we've continued to deepen our support for PDC. So we've added compatibility to an additional 20 data sources. We've also published some public documentation so that external plugin developers can also add support for this. And I want to thank those that have already made that move. Now, alongside the agent-based approach, something that we initially talked about middle of last year was an integration and partnership with Tailscale. So Tailscale is a modern networking platform, and it's just really nice for managing the connectivity between different devices on different networks. And it plays really well in that use case of connecting Grafana Cloud to something like a home lab with essentially zero additional operational overhead. And I'll show you how this looks in the demo shortly. But first, the Grafana instance that we're gonna base this demo on belongs to this gentleman, who happens to be the father of one of my PDC colleagues, Daf.

(01:05:47):

The child is going to be an intern that we blame whenever there's an incident. But his story will probably be quite familiar to a lot of you. So he has a weather station that's in his garden. He's using Grafana running on a Raspberry Pi. He's got InfluxDB being used to store time series data. And then he's using the Infinity data source to directly poke at that weather station.

(01:06:13):

He already uses Tailscale, and that's so that he can interact with his home assistant from his phone when he's outside the house. But maybe something's been missing. Maybe the key to his best growing season yet could be the ability to add an on-call rotor. So there's always someone responsible in case there's high winds to go close the window in the greenhouse. You could even establish an SLO around the ideal growing conditions. Now before PDC, he'd had to find a way to expose those data sources. Well, that can introduce hassle. I'm gonna show you how easy it is to add Grafana Cloud as a new machine on your tailnet.

(01:06:54):

Before I begin, I have already created the machine key in Tailscale to avoid having to live present Dafstad's tailnet. That would have been slightly awkward. But you can see the key on the right. So it's an ephemeral reusable key. You can add tags if you wanna do things with ACLs. But essentially, you just have to generate a token. That's the amount of work you have to do. I've also extracted the dashboard and the data sources that were being used on that OSS instance to my laptop. I'm logged in using a service account token with our new GCX CLI. If we hop to the demo, let's start playing around.

(01:07:43):

So this is my Grafana Cloud account. Currently, it doesn't have the dashboard, doesn't have the data sources. So let's change that. So GCX, which we announced yesterday, makes it really easy to interact with resources on Grafana Cloud. So this is what I have locally. I have my dashboard, which is on our new Kubernetes style API, and then the data sources, which are still defined using our legacy API. As it's my only resource defined in the Kubernetes manner, I can just do a simple GCX resources push and then pray. And it worked, which is great. And then as I say, the data sources are on the legacy API, but it's still really easy to work with them. So you just do GCX API, the API that you want to invoke, and the payload that you want to give it. So start with influx, and then we will add infinity, which is the other one.

(01:08:45):

So if I now go back to my cloud instance, hit refresh, I now have a new dashboard that's appeared. So as you'll start to see, this dashboard is trying to display various weather related information, such as the temperature. Obviously, it's a lot colder in the UK than it is in sunny Barcelona. Some of the panels are working, but some of them are failing. And if we look at the error message, some of you might be able to see that it's trying to access something on the local network. And unfortunately, we don't currently host Grafana Cloud in Dafstad's garage. So instead, we're gonna configure it so that we will communicate via Tailscale. So to do that, if I go into my data sources list, I do have the infinity and the influx data source here. And what PDC does is injects this additional piece of configuration into compatible data sources.

(01:09:43):

So you can either configure the agent based approach or Tailscale. With Tailscale, you just need to give it an arbitrary machine label. And this just helps you identify what's actually connecting on your tailnet, and give it an auth key. And hit save and test. Go back. Do influx. Same again. And because it would be slightly frowned upon to return credentials in plain text, I also have to add that back in.

(01:10:17):

So there we go. It's been promising. If I go back to my dashboard, voila. So we now have Grafana Cloud securely communicating to resources that are running on a private network somewhere in the south of England. And this is cool, right? There's basically zero additional operational overhead that I've had to do. I've just had to create a machine key and I've just had to update my data sources to use that token. So now, I can start to take advantage of all the Grafana Cloud features that are at my fingertips. So I could use synthetic monitoring to establish a probe. I could do that SLO. But I described talking about a on call rotor. I have already set that up just because it's fairly boring to watch that happen. But I'll show you how it all works. So essentially, I have an alert rule, which is here. And this very arbitrarily just looking at a low number for the wind. And if it's above one, it's gonna start to fire.

(01:11:24):

The way that the alert rule then works is it goes to the IRM notification. Sorry. The notification point is an IRM integration. So the integration then points at an escalation chain. The escalation chain looks at who is on call and sends a notification to them. So if I look at my on call rotor, unfortunately, I am the one on call right now. So I won't really be able to help with the greenhouse. But I will start to get shouted at in Slack. So you can see here, alert has just started to fire in Slack. And I can do everything here. So I can silence it. I can acknowledge it. I could also like directly declare an incident all from Slack. And there you have it. So you've seen how simple it is to connect private resources using PDC over tail scale. So whether you migrate or whether you want to take advantage of a hybrid approach, you can easily use Grafana Cloud features to extend your observability toolkit. And not just for like traditional observability, but also for more personal use cases like I've shown today. 'Cause we love seeing the new and imaginative ways that you find to use Grafana.

(01:12:44):

Can we head back to the slides?

(01:12:49):

Awesome. So that's what PDC and Grafana Cloud can unlock for you in terms of extending your use of Grafana. But now let's talk about your ability to extend Grafana with plugins. For those less familiar with plugins, they come in three types. There are panels, which add new visualizations. There are data sources, which adds the ability to from an external system. And applications, which can bundle the two, or you can use them to build dashboard-like experiences in custom Grafana pages. They're really, really flexible. And it's never been easier to build them. And I probably don't need to explain to you why. The two vowels that have taken over the world.

(01:13:34):

In this year's hands-on labs, Esteban and Timo took a group of people through the experience of prompting their way to having working Grafana plugins. Plural. You've been sat here for a long time, so we'll try a bit of audience participation. Who here was at that workshop? Can you raise your hands? And keep them raised if you've got at least one of the plugins working. Good. So it was basically everyone, barring some issues with code spaces, which we promise wasn't our fault. When we ran this workshop last year in Seattle, still archaically typing code, we at best got about 40% through. So this is the new reality. This is plugin development in 2026. The barrier to entry has never been lower.

(01:14:22):

And as we were preparing for this workshop, we were already experiencing a significant rise in submissions to the catalog. And something that you may be experiencing is the use of agentic tooling shifts a lot of our responsibility to the review stage. You might see it in your own companies. You might have read it being documented in how app stores are starting to feel this. Now, the use of this tooling is an inevitability, and it's wonderful. So as such, we're investing in the best ways to support you to use these tools to create high-quality plugins, but still retain that understanding of what the code is trying to do.

(01:15:02):

Now, some of the things that we found generally useful so far include scaffolding a best practice agents MD file with our create plugin tool. And we still strongly recommend running that tool first and then switching to something like Claude Code. Because if you start with the LLM, then it still has that ability to hallucinate and create backend panels, which is a very, very strange thing. We're also starting to explore a new add command in create plugin to reliably extend scaffolded plugins. And we started doing this in support of the React 19 migration. So React 19 is coming to Grafana 13. And we use the add command to make it easier for plugin developers to externalize the JSX runtime. We've also added an LLMs.txt to our developer portal, and then that agents MD file instructs the agent to not just rely on training data, but instead fetch the latest guidance using that.

(01:16:04):

We'll continue to invest, adapt, explore as this landscape evolves, but as always, we'll really welcome your suggestions, your PRs, not just in Grafana, but in our developer tooling.

(01:16:17):

I also wanted to take a moment to share something that you may or may not know. But every plugin, all the 200 odd third-party plugins that exist in the Grafana catalog today, has been reviewed by a human. And yes, we do have an increasingly thorough set of automation. Yes, we are using AI as well. But there is a human at the end of that ticket. They are the ones that are providing guidance or concrete suggestions on how you can improve your plugins, and we wanna keep doing that. We really value this as an opportunity to help you better understand plugin development, but also hear about your experience and how we can improve what it's like to develop plugins. Let's keep that human connection.

(01:17:02):

Now let's talk about why to build plugins in the first place. There is a wide variety of plugins available in the catalog today, covering everything from traditional observability to calculating the position of the sun and the moon. In the UK, it's often behind a cloud. However, like with lots of free software, there's variation in how frequently these plugins get updated. That can sometimes introduce risk like with new Grafana compatibility or just other issues that impact plugins that you've come to depend on. But the maintenance of these plugins comes at a real cost to developers' time. So we need to make sure that there's the appropriate incentives to balance that demand. And with that in mind, I'd like to share some details about a new initiative, the Grafana Marketplace.

(01:17:54):

So our intent for the Marketplace is that it puts even more plugins at your fingertips, but that it rewards plugin developers for their ongoing maintenance and feature development. And that ultimately it provides a platform for freelancers, systems integrators, and others to build viable businesses that support Grafana users to be successful. The Marketplace will allow developers to list plugins for a flat fee or a per-user-based subscription price, very similar to how our enterprise data sources work. We, Grafana, will handle billing and procurement, so you can focus on the plugin. But there will be expectations when plugins come with a fee. Things like an SLA for security patches and an expectation around support. And we're continuing to work on the finer details here, 'cause we do want to make sure that we get that right balance between what works for our developers and what works for you, our users.

(01:18:56):

We also believe that based on ongoing conversations with existing plugin developers, that free open-source plugins will exist in our community and our ecosystem as they always have done. The Marketplace is no attempt to change that. The Marketplace is just providing new optionality that didn't exist before. And the optionality is already unlocking new plugins in our ecosystem. So I'm really excited to share some details of the partners that we've worked with on this very initial pilot and what they have to offer. So first, we have an IT and security-oriented set of plugins from Crest Data. Then we have from KensoBI, a suite of industrial manufacturing suited plugins which add CAD support to Grafana. And finally, Phenysys have an application which helps you get more understanding about how your teams are using Microsoft Teams.

(01:19:52):

I do wanna give a special thank you to these organizations who've partnered with us to bring this initial offering to life. Now, with the launch of this pilot, we're laying the groundwork for the Marketplace to evolve, much in the same way that we see Grafana evolving as an application platform. We want you to be able to build rich, complex applications, distribute them to 35 million active Grafana users, and monetize this all on top of Grafana. So if this sounds interesting to you, if you're sitting on a plugin, now is the time. Because alongside this launch, we're introducing a founding partner program, where if you submit and apply by the 30th of September, then you'll qualify for an additional promotion. To provide feedback, to apply to the founding partner program, or to sign up just for updates, you can scan this QR code, or you can drop us an email at plugins-marketplace at grafana.com, or come find me or a few of us at the Ask the Experts booth later.

(01:20:55):

And I wanna stress, we want to hear from you. We want this to be the Grafana Marketplace that really works for our community. So as I say, if you're a developer, a server admin, an open source enthusiast, come talk to us.

(01:21:13):

And as always, it's time to wrap this up, but we have not really had enough time to talk about everything, but hopefully between the keynote and today, you've had an introduction to some of the most exciting features that we're bringing in Grafana 13. It's faster than ever to get started, and it's not just features like suggested dashboards, or visualization suggestions, or templates, but things like our interactive learning pathways that make it really easy to level up your Grafana abilities and help teams on board faster. Grafana 13 truly solves the blinking cursor problem. We then have things like dynamic dashboards, which make dashboarding even more powerful, able to adapt to different use cases, different personas, allow you to consolidate into the single source of truth. Then with Git Sync and schemas, all of your resources become easier and more reliable to manage at scale. And speaking of easier, with Grafana Assistant, now available with both cloud on-premise as well, you can use natural language to interact and change your Grafana estate.

(01:22:24):

And finally, as I just shared, the Grafana Marketplace hopefully introduces whole new use cases and wonderful opportunities for our community. We ship continuously, so if you're using Grafana Cloud, you may have already enjoyed some of these features, but no matter how you use Grafana, we're incredibly excited to share this latest version with you. Please try it out, give us your feedback, because our community makes Grafana. We are nothing without you. So thank you for being here. I hope you have a great rest of the conference. Enjoy.