0Pricing
Load Testing & Performance Benchmarking (JMeter & k6) · Lesson

Virtual User Scenarios (VUs)

Define and manage various virtual user scenarios to simulate diverse load patterns effectively.

Virtual User Scenarios (VUs) is a free Load Testing & Performance Benchmarking (JMeter & k6) lesson on CoddyKit — lesson 1 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Load Testing & Performance Benchmarking (JMeter & k6) learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Beyond Simple Load: k6 Scenarios

When performance testing, a simple 'run 10 VUs for 30 seconds' might not capture real user behavior. Real users often have different patterns: some log in, some browse, some make purchases. This is where k6 scenarios come in!

Scenarios allow you to define complex load profiles and simulate diverse user groups, each with its own specific behavior and load pattern, all within a single test script.

Defining Your Test Scenarios

In k6, you define scenarios within the options object of your test script. The scenarios block is a JavaScript object where each key represents a unique scenario name.

Each scenario specifies an executor, which dictates how virtual users (VUs) and iterations are managed. It also links to a specific function in your script that defines what those VUs will do.

import http from 'k6/http';
import { sleep } from 'k6';

export const options = {
  scenarios: {
    // Scenario definitions go here
  },
};

export default function () {
  http.get('https://test.k6.io');
  sleep(1);
}

Basic Scenario: Shared Iterations

The default k6 executor, shared-iterations, distributes a fixed number of iterations among a pool of VUs. Each VU will execute as many iterations as it can until the total specified iterations are complete or the test duration ends.

It's good for tests where you want to complete a specific amount of work.

import http from 'k6/http';
import { sleep } from 'k6';

export const options = {
  scenarios: {
    my_scenario: {
      executor: 'shared-iterations',
      vus: 5,
      iterations: 20,
      maxDuration: '30s',
    },
  },
};

export default function () {
  http.get('https://test.k6.io');
  sleep(1);
}

Constant Load with `constant-VUs`

The constant-VUs executor maintains a fixed number of virtual users throughout the test's duration. VUs are started at the beginning and kept active until the duration is met.

This is useful for simulating a steady, continuous load on your system.

import http from 'k6/http';
import { sleep } from 'k6';

export const options = {
  scenarios: {
    constant_load: {
      executor: 'constant-VUs',
      vus: 10,
      duration: '1m', // Run 10 VUs for 1 minute
    },
  },
};

export default function () {
  http.get('https://test.k6.io/news.php');
  sleep(2);
}

Gradual Load with `ramping-VUs`

The ramping-VUs executor allows you to gradually increase or decrease the number of virtual users over time. This simulates a more realistic load curve, like users slowly joining a website or leaving it.

It uses stages to define these changes in VU count.

import http from 'k6/http';
import { sleep } from 'k6';

export const options = {
  scenarios: {
    gradual_load: {
      executor: 'ramping-VUs',
      startVUs: 0,
      stages: [
        { duration: '30s', target: 20 }, // Ramp up to 20 VUs over 30s
        { duration: '1m', target: 20 },  // Stay at 20 VUs for 1 minute
        { duration: '20s', target: 0 },  // Ramp down to 0 VUs over 20s
      ],
    },
  },
};

export default function () {
  http.get('https://test.k6.io/contacts.php');
  sleep(1);
}

Structuring Load with Stages

Within ramping-VUs, stages are an array of objects, each with a duration and a target VU count.

  • duration: How long this stage lasts (e.g., '1m', '30s').
  • target: The number of VUs to reach by the end of this stage. k6 will linearly ramp VUs from the current stage's end target to the next stage's target.

Stages are powerful for modeling complex load patterns like peak hours or sudden traffic spikes.

Controlling Request Rate: `ramping-arrival-rate`

Unlike VU-based executors, ramping-arrival-rate is an open model executor. It controls the rate at which new iterations (or 'arrivals') are started, rather than the number of VUs.

This is ideal for testing systems where you care about requests per second (RPS) or transactions per second (TPS).

import http from 'k6/http';
import { sleep } from 'k6';

export const options = {
  scenarios: {
    arrival_rate_test: {
      executor: 'ramping-arrival-rate',
      startRate: 0, // Initial iterations per second
      timeUnit: '1s', // How often 'rate' is applied
      stages: [
        { duration: '30s', target: 10 }, // Ramp up to 10 iterations/s over 30s
        { duration: '1m', target: 10 },  // Stay at 10 iterations/s for 1 minute
      ],
      preAllocatedVUs: 20, // Initial VUs to allocate
      maxVUs: 50,         // Max VUs to spin up if needed
    },
  },
};

export default function () {
  http.get('https://test.k6.io/login.php');
  sleep(0.5); // Simulate some user think time
}

Combining Different User Behaviors

You can define multiple, independent scenarios within a single k6 script. Each scenario can have its own executor, VUs, duration, and even call a different function that defines its specific user journey.

This allows you to simulate a mix of user types (e.g., admin users, regular users, guests) in one comprehensive test.

import http from 'k6/http';
import { sleep } from 'k6';

export const options = {
  scenarios: {
    anonymous_browsing: {
      executor: 'constant-VUs',
      vus: 5,
      duration: '30s',
      exec: 'anonymousBrowser', // Call this function
    },
    authenticated_user: {
      executor: 'ramping-VUs',
      startVUs: 0,
      stages: [{ duration: '20s', target: 3 }],
      exec: 'loggedInUser', // Call this function
    },
  },
};

export function anonymousBrowser() {
  http.get('https://test.k6.io/');
  sleep(2);
}

export function loggedInUser() {
  // Simulate login (not actual login, just for demo)
  http.post('https://test.k6.io/login', { username: 'user', password: 'pass' });
  sleep(1);
  http.get('https://test.k6.io/my-profile');
  sleep(2);
}

Fine-Tuning Scenario Execution

Beyond basic executor settings, scenarios offer additional options for precise control:

  • startTime: Delay the start of a specific scenario (e.g., '10s' after test start). Useful for staggered tests.
  • gracefulStop: How long k6 should wait for active VUs to finish their current iteration before forcefully stopping them (e.g., '5s').
  • env: Environment variables specific to this scenario.

These options help orchestrate complex test flows.

Scenario Challenge

You need to simulate a load test where:

  • 5 virtual users (VUs) constantly browse the homepage for 1 minute.
  • At the same time, another group of users gradually ramps up from 0 to 10 VUs over 30 seconds, then holds at 10 VUs for 30 seconds, performing a login action.

Which two k6 executors would be most appropriate for these two distinct user behaviors?

Scenarios: Your Load Orchestrator

In this lesson, you've learned how k6 scenarios enable you to model diverse and realistic load patterns. We explored key executors:

  • shared-iterations for fixed work.
  • constant-VUs for steady load.
  • ramping-VUs for gradual load changes with stages.
  • ramping-arrival-rate for open-model testing based on request rate.

You also saw how to combine multiple scenarios and use options like startTime for advanced control. Mastering scenarios is crucial for sophisticated performance testing!

Frequently asked questions

Is the “Virtual User Scenarios (VUs)” lesson free?

Yes — the full text of “Virtual User Scenarios (VUs)” is free to read here on the web, and the Load Testing & Performance Benchmarking (JMeter & k6) course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Load Testing & Performance Benchmarking (JMeter & k6) course, upgrade to CoddyKit PRO.

What will I learn in “Virtual User Scenarios (VUs)”?

Define and manage various virtual user scenarios to simulate diverse load patterns effectively. You practise Load Testing & Performance Benchmarking (JMeter & k6) with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Load Testing & Performance Benchmarking (JMeter & k6)?

No prior experience is required. Load Testing & Performance Benchmarking (JMeter & k6) on CoddyKit is structured for beginners through advanced learners; this is — lesson 1 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Virtual User Scenarios (VUs)” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Load Testing & Performance Benchmarking (JMeter & k6) lesson?

Yes. Every Load Testing & Performance Benchmarking (JMeter & k6) lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. Virtual User Scenarios (VUs)
  2. Data Parameterization in k6
  3. Cloud Execution with k6
  4. Custom Metrics and Trends in k6
← Back to Load Testing & Performance Benchmarking (JMeter & k6)