An open source app for easily building performance tests: Grafana k6 Studio is generally available

Here at Grafana Labs, we have an on-going commitment to providing solutions that increase productivity without sacrificing ease-of-use. Last year, in line with that effort, we introduced experimental and public preview releases of Grafana k6 Studio, an open source desktop application that helps you create k6 test scripts quickly and easily via a visual interface.

Today, we’re excited to share the general availability of k6 Studio v1.0.

k6 Studio addresses a clear and consistent message we’ve heard from our users: test authoring is hard. Writing tests manually can be slow, frustrating, and error-prone, especially when you don’t have full visibility into the system under test. We knew we needed to lower the barrier to entry, making test creation more intuitive and accessible without sacrificing the flexibility or power of Grafana k6.

Here, we’ll take a closer look at what k6 Studio is, how it works, and what’s next. You can also check out a demo in the video below.

What is k6 Studio?

k6 Studio is an open source application that enables a wide range of users, including QA engineers and software developers, to create performance tests more quickly and easily using a visual interface. 

Whether you are testing a website that you’ve developed or a black box service without access to the source code, k6 Studio allows you to generate a performance test in minutes. You don’t need to be an expert in JavaScript or our scripting API to create powerful, production-ready scripts. For developers who are familiar with k6, k6 Studio can optimize the time it takes to create a script and provide tools to validate and debug scripts outside of the k6 CLI.

More specifically, k6 Studio allows you to:

• Record a user flow from browser interactions and generate a HAR file.
• Generate and customize a k6 test script from a HAR file, and use rules to quickly iterate on the script creation process.
• Test and debug k6 scripts using a visual interface. Inspect the request and response details for any request in your script.

k6 Studio is designed to help you write test scripts for Grafana k6, the open source, modern performance testing tool. You can also use the scripts you write in k6 Studio to create tests in Grafana Cloud k6, the fully managed performance testing platform powered by k6 OSS, and to run k6 scripted checks in Grafana Cloud Synthetic Monitoring.

The spark of inspiration for k6 Studio

Early last year, the Grafana k6 team held an offsite where we challenged ourselves to step into the shoes of a performance tester. We were handed a system we had never seen before and given a test scenario to follow.

Team members took entirely different approaches, from manual scripting to using AI. That said, we found one important thing in common: in most cases, it took us over 10 minutes to create the test itself. We knew a lot of users faced a similar challenge when it came to authoring tests. 

In that same exercise, we then used an early prototype of k6 Studio, and it took under two minutes to create a fully working test script — no coding required. From there, we got to work on the experimental release. 

How k6 Studio works

The k6 Studio application consists of three components: Recorder, Generator, and Validator. Let’s take a look at each. 

Recorder: recording a user flow 

Test authoring can be a difficult process, especially when the inner workings of the system under test are unknown. Grafana k6 Studio offers a recorder-based test authoring experience. Using the Recorder component, you can capture interactions in the browser and inspect the recorded HTTP requests and responses.

Generator: configuring the test logic

Once you’ve recorded your user flow, the Generator component allows you to convert recordings into k6 test scripts.

It lets you define your test options, such as the load profile; add test data, such as variables and data files; and most importantly, fine-tune your test using test rules. All of this can be done without having to touch code (if you don’t want to).

When the test script is generated, test rules are applied to the recording to correlate response data, parameterize the request data, and verify the responses. These rules reflect the common tasks you need to perform to get to the point of having a working test script.

Let’s take the correlation rule as an example. It lets you extract a value from one or multiple responses and use it to replace data in other requests — for example, you could extract the CSRF token from the response and use it in the subsequent requests.

The parameterization rule, which represents one of the most common tasks in performance testing, lets you parameterize your requests to use a text or other value from a variable. Maybe you have a list of test data like:

• Emails 
• Product SKUs
• Credit card numbers (dummy ones of course) 
• Zip codes from every time zone 
• Every possible spelling of “johnathan” 
• The entire unicode emoji set 
• Horoscope predictions to see if mercury is in retrograde

With k6 Studio, you can easily import CSV or JSON data files and use them in your test! Simply import a file, create a parameterization rule, and start testing. 

Validator: validating the script 

Historically, debugging a script involved running it and checking for errors in the logs. The Validator component in k6 Studio facilitates this process by enabling users to perform a detailed inspection of every request and response individually. 

This offers a tight feedback loop, allowing you to make modifications and quickly validate the script while working on it.

Run the performance test 

Once you’ve created your test script in k6 Studio, the next step is to run it! 

You have three options:

1. Trigger a test locally using the k6 CLI: This is a good option if your tests are going into a CI pipeline, or you are saving your tests into version control. 

2. Trigger a Grafana Cloud k6 test to start immediately from k6 Studio: If you’re preparing for a high-traffic event, like Black Friday, or if you’re conducting a one-off testing scenario, you can just trigger the test in Grafana Cloud k6 directly from k6 Studio with the push of a button. 

3. Use your recorded script to create a check in Grafana Cloud Synthetic Monitoring: While this option is a bit more manual than the other two, you can use a recorded script from k6 Studio to create a scripted check in Grafana Cloud Synthetic Monitoring, helping to monitor transactions and user journeys.

What’s next

First, a big shoutout to the team for the amazing work they’ve done on k6 Studio so far. Our hope is that this open source application will significantly simplify and streamline the test creation process, even for those who are just getting started with performance testing.

We look forward to your feedback and know it will be invaluable in shaping the future of k6 Studio. Please reach out in our community forums, on GitHub, or on Slack! You can also learn more about the k6 Studio app in our technical documentation. 

Lastly, looking ahead, we plan to add support for authoring browser tests in k6 Studio, so you can more easily write tests to simulate user interactions with your web applications and ensure optimal end-user experiences. We also hope to make the existing integration between k6 Studio and Grafana Cloud Synthetic Monitoring even more seamless in the future, so you can kick off the check creation process within the k6 Studio app. 

Please stay tuned, let us know what you think, and, as always, happy testing!

Grafana Cloud is the easiest way to get started with Grafana k6 and performance testing. We have a generous forever-free tier and plans for every use case. Sign up for free now!