<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>User guide on Step Documentation</title>
    <link>https://step.dev/knowledgebase/30/categories/user-guide/</link>
    <description>Recent content in User guide on Step Documentation</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en</language>
    <lastBuildDate>Mon, 24 Nov 2025 08:08:01 +0100</lastBuildDate><atom:link href="https://step.dev/knowledgebase/30/categories/user-guide/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Calling Keywords in Plans</title>
      <link>https://step.dev/knowledgebase/30/userdocs/plans/keywords-in-plans/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/plans/keywords-in-plans/</guid>
      <description>Keywords serve as the fundamental building blocks for implementing automation. From a business perspective, a Keyword symbolizes a functionality to be automated. It might represent a fully automated flow or be as simple as a single user action or service call. A Plan represents an automated scenario and will normally consist of one or more Keywords. Whenever a Keyword is encountered during Plan execution, it leads to a Keyword call. This section focuses on the usage of Keywords within a Plan.</description>
    </item>
    
    <item>
      <title>Keywords</title>
      <link>https://step.dev/knowledgebase/30/userdocs/keywords/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/keywords/</guid>
      <description>This section will focus on registering and using already-developed keywords. To learn how to develop a keyword, check the Developer guide overview.
What is a Keyword? Keywords in Step are the fundamental building blocks of Plans. They encapsulate the automation logic (often called scripts). They can represent fully automated flows or finer-grained actions, such as user interactions or service calls. Employing finer granularity is generally preferred as it enhances reusability across multiple business flows through Plans.</description>
    </item>
    
    <item>
      <title>Measurements and Metrics</title>
      <link>https://step.dev/knowledgebase/30/userdocs/analytics/measurements-and-metrics/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/analytics/measurements-and-metrics/</guid>
      <description>Step analytics are built on two complementary data types:
Measurements A measurement is a named, timed observation attached to a plan&amp;rsquo;s execution step. Each measurement captures a name, a duration in milliseconds, a start timestamp, a status (PASSED, FAILED, or TECHNICAL_ERROR), and optional custom attributes (key/value pairs).
Measurements are created automatically by the Step framework for keyword calls as well as for instrumented plan nodes. Custom measurements with finer granularity or enriched attributes can also be defined in keyword code (see Measurements in the Keyword API).</description>
    </item>
    
    <item>
      <title>Notifications</title>
      <link>https://step.dev/knowledgebase/30/userdocs/alerting-notifications/notifications/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/alerting-notifications/notifications/</guid>
      <description>Step includes a flexible mechanism for sending notifications using various methods. Such notifications are meant to work in tandem with the Alerting Rules, allowing to define exactly which events and conditions will result in which notification being sent, with what data.
In order to use Preset-based notifications, Step administrators must define at least one System Notification Preset. Introduction and Example Step currently supports two kinds of notifications: good old E-Mails, and Webhook calls.</description>
    </item>
    
    <item>
      <title>Deployment of Keywords</title>
      <link>https://step.dev/knowledgebase/30/userdocs/keywords/keywords-deployment/</link>
      <pubDate>Mon, 19 Jun 2023 00:00:00 +0000</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/keywords/keywords-deployment/</guid>
      <description>You can add and manage Keyword by manual registration or automatically using package file. In this guide, we will first discuss ways of adding Keywords via package file. For description about the manual way of adding Keywords, please see the section: Adding a new Keyword by manual registration.
Adding a new Keyword by manual registration In order to use your Keywords with Step, you need to register them. This can be done through the web interface or the Java API.</description>
    </item>
    
    <item>
      <title>Controls</title>
      <link>https://step.dev/knowledgebase/30/userdocs/plans/controls/</link>
      <pubDate>Thu, 23 May 2019 07:00:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/plans/controls/</guid>
      <description>Step supports a wide range of so-called controls to build-up complex flows in Plans. The supported controls range from classical control structures (like if blocks, loops, etc) to use-case specific controls like thread groups for load-testing, data-sets, etc. This page provides details about all the controls supported by Step.
General controls Set The Set control allows to define a variable and assign it a value. Variables defined with Set controls can be accessed according to their scope throughout Plans and sub Plans.</description>
    </item>
    
    <item>
      <title>Alerting rules</title>
      <link>https://step.dev/knowledgebase/30/userdocs/alerting-notifications/alerting/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/alerting-notifications/alerting/</guid>
      <description>Step includes a rule-based mechanism that allows users to define flexible reactions to various events.
In a nutshell, rules allow you to define when to react to specific events (conditions), and how (actions).
The following illustration presents the process in a simplified, informal form:
Events Events are automatically generated by the Step environment and fed into the alerting rules evaluation component. Events contain further details about what happened, in the form of Bindings.</description>
    </item>
    
    <item>
      <title>Dashboards</title>
      <link>https://step.dev/knowledgebase/30/userdocs/analytics/dashboards/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/analytics/dashboards/</guid>
      <description>Managing Dashboards: Overview The Dashboard List page provides a straightforward way to manage all your dashboards. This feature simplifies how you handle various analytics dashboards, making it more efficient to work with your data.
Step comes with 4 pre-populated dashboards:
Execution dashboard: used to analyse the performance of a single Step execution Analytics dashboard: meant to be used for schedules performance analysis, also accessible from the monitoring view Executions Overview: tracks per-execution metrics (execution count, duration, failure rate) generated at the end of each execution, giving a historical view of campaign health over time Grid Monitoring: displays agent health and activity metrics; not project-specific and accessible from any tenant Key features: Create: Easily add new dashboards for different data sets or projects.</description>
    </item>
    
    <item>
      <title>Reporting</title>
      <link>https://step.dev/knowledgebase/30/userdocs/executions/execution-reporting/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/executions/execution-reporting/</guid>
      <description>This page describes the new Execution Report page. You can choose to use the Legacy Execution Report page instead. (read more)
Note: The Execution Report will automatically revert to the legacy page for executions prior to Step 27.
The Execution Report provides insight into an ongoing or already concluded execution. The following general information is shown at the top:
The current status of the execution The name of the executed plan A link to the plan The date when the plan was executed The user who initiated the execution Click to open a table of all resolved parameters Click to see on which agent(s) the plan was executed A list of execution parameters Displays a searchable table of all execution parameters Select the layout used to display the report Modify / create a custom report layout Test Cases If the executed plan contains more than one test case, a panel lists the status of each.</description>
    </item>
    
    <item>
      <title>Reporting (legacy)</title>
      <link>https://step.dev/knowledgebase/30/userdocs/executions/legacy-execution-reporting/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/executions/legacy-execution-reporting/</guid>
      <description>The legacy Execution Report page will be deprecated starting with Step 30. Executions give you an insight in the results of an executed Plan as well as the ability to detect and analyze errors, both within the Plan or the system tested / automated with it.
Execution steps On the Execution list view, clicking on the Plan name of an Execution redirects you to the details of that execution. The Execution steps view shows the details of the executed Plan, as shown in the following screenshot.</description>
    </item>
    
    <item>
      <title>Keyword Configuration</title>
      <link>https://step.dev/knowledgebase/30/userdocs/keywords/configuring-keywords/</link>
      <pubDate>Sun, 18 Jun 2023 00:00:00 +0000</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/keywords/configuring-keywords/</guid>
      <description>Step offers holistic business use cases that lets business and technical users reuse different automation components. To enhance interaction quality and prevent input mismatches, users can specify mandatory information required to execute a specific Keyword.
Schema Optional and mandatory input keys can be specified in the form of a JSON schema tied to the Keyword. Schema can be provided manually as part of the Keyword&amp;rsquo;s generic fields or automatically populated based on the &amp;ldquo;schema&amp;rdquo; attribute of the Keyword annotation in Java and .</description>
    </item>
    
    <item>
      <title>Using variables in Plans</title>
      <link>https://step.dev/knowledgebase/30/userdocs/plans/plans-variables/</link>
      <pubDate>Thu, 23 May 2019 07:00:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/plans/plans-variables/</guid>
      <description>Variables are used throughout plans to pass information from one node to another, or to store the result of a dynamic computation.
Variable types Similar to any programming language, Step supports the use of variables in Plans. The variables declared and used in a Plan are called Plan variables. A Plan variable is a container that stores a data value under a specific name.
Like in classical programming languages, Step supports the following types of variables:</description>
    </item>
    
    <item>
      <title>Execution Subscriptions</title>
      <link>https://step.dev/knowledgebase/30/userdocs/alerting-notifications/subscriptions/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/alerting-notifications/subscriptions/</guid>
      <description>From a user&amp;rsquo;s perspective, it is often useful to be notified about certain events, like the execution (or failure) of particular plans. This is possible by leveraging the functionality of the Alerting Rules and Notifications.
Expert users can create the corresponding rules themselves, however this is not necessarily a straightforward task, and figuring out the exact definitions may be cumbersome. Therefore, Step provides a simple Wizard which allows to set up notifications in an easy way.</description>
    </item>
    
    <item>
      <title>Plan modularity</title>
      <link>https://step.dev/knowledgebase/30/userdocs/plans/other-plans/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/plans/other-plans/</guid>
      <description>Calling another Plan To enable modular design of Plans Step makes it possible to recursively call other Plans.
Using the Visual Plan Editor you can easily call other Plans using the tab &amp;ldquo;Other plans&amp;rdquo; from the component list:
Using the plain-text syntax other plans can be called using the following syntax
Call plan &amp;#34;Test Case 01&amp;#34; Call plan &amp;#34;Test Case 02&amp;#34; Call plan &amp;#34;Test Case 03&amp;#34; Composite Keywords You can also achieve modularity using so called composite keywords.</description>
    </item>
    
    <item>
      <title>Plans</title>
      <link>https://step.dev/knowledgebase/30/userdocs/plans/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/plans/</guid>
      <description>A Plan in Step is the implementation of an automation scenario such as a functional test case, a load test, an RPA routine, or a synthetic monitoring probe. Plans combine building blocks called Keywords with various controls that build up the execution logic of the automation scenario.
As a beginner, make sure to understand the key concepts explained in the following sections before creating your first Plan. You will also find various ways to create different types of Plans in our tutorials.</description>
    </item>
    
    <item>
      <title>Archiving</title>
      <link>https://step.dev/knowledgebase/30/userdocs/executions/execution-housekeeping/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/executions/execution-housekeeping/</guid>
      <description>If Automatic housekeeping is ON, you may want to flag the executions to be retained by the housekeeping job. To do that, toggle the Retain this execution and provide the information about your execution in the Description textbox - for example, information about a referenced execution that’s part of an overall test release. On the other hand, if you don’t want to retain this specific execution, you may directly delete it within the same pane:</description>
    </item>
    
    <item>
      <title>Executions</title>
      <link>https://step.dev/knowledgebase/30/userdocs/executions/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/executions/</guid>
      <description>An Execution represents the result of a specific run of a Plan. It contains comprehensive information about the Keywords and controls within an executed Plan, including status, output values, performance measurements, and more.
Executing a Plan You can run a Plan, and create a new corresponding Execution by clicking the &amp;ldquo;play&amp;rdquo; button available in the Plan list, Keywords list and the Plan editor: This will display the following Execution panel, specifying the Execution environment and the Execution mode.</description>
    </item>
    
    <item>
      <title>Visual Plan editor</title>
      <link>https://step.dev/knowledgebase/30/userdocs/plans/visual_plan_editor/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/plans/visual_plan_editor/</guid>
      <description>The Visual plan editor is the most basic and straight-forward way to create a Plan in Step. When using the Visual interface, you create your Plan in a code-free intuitive editor that gives instant access to the libraries of available Keywords and Controls. Using the Visual interface makes it possible to create a Plan in an intuitive manner without technical skills and prior knowledge of Step. It is also well-suited for complex automation plans which require a visual representation of the Plan.</description>
    </item>
    
    <item>
      <title>Automation Packages View</title>
      <link>https://step.dev/knowledgebase/30/userdocs/automation-package-ui/</link>
      <pubDate>Mon, 24 Nov 2025 08:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/automation-package-ui/</guid>
      <description>While Automation Packages are primarily designed to be created, deployed, and executed through the CLI or Maven plugin as part of a CI/CD workflow, the Step UI also provides convenient tools to deploy and execute Automation Packages and their libraries directly.
The UI is additionally the only place where you can view, inspect, and delete deployed Automation Packages and libraries, and where certain package-specific configuration options, such as routing rules or screen templates, are available.</description>
    </item>
    
    <item>
      <title>Advanced executions</title>
      <link>https://step.dev/knowledgebase/30/userdocs/executions/execution-advanced/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/executions/execution-advanced/</guid>
      <description>Performance optimizations For load test executions with extreme high load, depending on your system capacity, creating and persisting a report for each and every node execution will impact the maximum load your Step scenario can generate. In such cases, it is possible to disable the persistence of the nodes by setting one or more of the listed predefined variables, in the case of using a set control):
tec.execution.reportnodes.persistbefore = false: This only persist the node state after its execution; thus you won’t see the nodes in RUNNING state but will have all information needed for your analysis and reporting.</description>
    </item>
    
    <item>
      <title>Plain text plans</title>
      <link>https://step.dev/knowledgebase/30/userdocs/plans/plaintext_plans/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/plans/plaintext_plans/</guid>
      <description>In addition to the Visual Plan editor Step comes along with a full-featured parser which enables the creation of Plans using a plain-text human-friendly syntax.
The plain-text format has different advantages over the Visual interface. Using the plain-text format makes it possible to manage Plans in a same manner as code and thus enables the use of version control system like git, text editors, etc. It also enables the integration with classical Test-Management Tools initially developed for manual test specification and thus based on plain-text test-cases specifications.</description>
    </item>
    
    <item>
      <title>Agent provisioning</title>
      <link>https://step.dev/knowledgebase/30/userdocs/agent-provisioning/</link>
      <pubDate>Mon, 30 Sep 2024 00:00:00 +0000</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/agent-provisioning/</guid>
      <description>When running in Kubernetes, Step supports automatic provisioning of Agents (i.e. automatic provisioning of the containers responsible for executing Keywords) across multiple Kubernetes clusters. This page explains how to utilize Agent provisioning in Plans.
For information on enabling or configuring Agent provisioning, please refer to the Agent Provisioning configuration page.
How it works In a nutshell, the automatic Agent provisioning works as follows:
Upon execution, Plans are scanned to determine the required Agents for execution Based on the calculation and the available Agent pools, the optimal number of Agents per Agent pool is calculated The required Agents are provisioned across the clusters of the selected Agent pools Once the Agents have joined the grid, the execution starts After execution, the agents are de-provisioned Configure provisioning settings in Plans When Agent provisioning is enabled in Step, users can configure the Agent provisioning settings in each plan (in the UI and in the automation packages).</description>
    </item>
    
    <item>
      <title>Alerting and notifications</title>
      <link>https://step.dev/knowledgebase/30/userdocs/alerting-notifications/</link>
      <pubDate>Mon, 17 Mar 2025 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/alerting-notifications/</guid>
      <description>Step includes a flexible mechanism for sending notifications in tandem with the definition of Alerting Rules, allowing to define exactly which events and conditions will result in which notification being sent.</description>
    </item>
    
    <item>
      <title>Schedules</title>
      <link>https://step.dev/knowledgebase/30/userdocs/schedulerview/</link>
      <pubDate>Sun, 29 Nov 2020 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/schedulerview/</guid>
      <description>Schedules allow to configure the recurring or one-time execution of Plans, enabling automated, time-based workflow execution for tasks like synthetic monitoring and beyond.
For the schedules to work correctly, ensure to properly set up the controller’s machine timezone before you start it. Description Let’s describe the Step schedules view: You can access it by clicking “Schedules” on the sidebar menu:
Here is the column description:
Name (1): the name of the schedule.</description>
    </item>
    
    <item>
      <title>Incidents</title>
      <link>https://step.dev/knowledgebase/30/userdocs/incidents/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/incidents/</guid>
      <description>Incidents are used to be aware of problems in the infrastructure: for instance, Step can periodically run plans which test the behavior of a system. When these plans fail to execute correctly, or (user-defined) assertions concerning the performance do not hold, this constitutes an incident.
Step allows incidents to be automatically created and managed according to user-defined alerting rules. These rules are evaluated in response to various events (most notably after every plan execution).</description>
    </item>
    
    <item>
      <title>Java Plan API</title>
      <link>https://step.dev/knowledgebase/30/userdocs/plans/java_plans/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/plans/java_plans/</guid>
      <description>Programmatic plans are the object-oriented representation of a plan. It can be particularly useful for developpers to design, execute and maintain Plans directly in Java.
See programmatic examples as part of the stepClient API here.</description>
    </item>
    
    <item>
      <title>Monitoring</title>
      <link>https://step.dev/knowledgebase/30/userdocs/monitoringview/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/monitoringview/</guid>
      <description>If you’ve purchased the Monitoring package or are running the Premium Enterprise version of Step, you’ll be able to view the status of your Plans scheduled entries. This is very useful for the purpose of building a monitoring dashboard that would be exposed to a support team.
Monitoring View To open it select Reporting -&amp;gt; Monitoring in the sidebar menu.
Name (2): the name of the Scheduler that is monitored - clicking it opens the schedules execution report Plan Link (3) navigate to the connected plan by clicking on the file icon next to the name Cron Expression (4): the expression used in the Plan scheduling entry Last execution (5): the last executions end date-time - clicking on the date navigates to that execution Last status change (6): the last time the Plan execution overall status has changed (from FAILED to PASSED for instance) Status (7): the last Plan execution status Action: execute (8), edit (9), or analyze (10) the Schedule Select which plans to monitor (1) The Monitoring View displays an entry for each Scheduler, so in order to monitor a plan it needs to have a scheduled execution.</description>
    </item>
    
    <item>
      <title>Parameters</title>
      <link>https://step.dev/knowledgebase/30/userdocs/parameters/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/parameters/</guid>
      <description>Parameters are centrally defined variables that can be accessed by both Keywords and Plans in Step. They offer several key capabilities:
Scope Assignment: Parameters can be assigned to specific scopes, restricting their visibility and access to certain applications or keywords. Protection of Sensitive Parameters: Sensitive parameters can be protected to hide their values from users, ensuring secure handling of critical data. Activation Expressions: Parameters can be dynamically assigned or mapped to specific environments, users, or other conditions using activation expressions.</description>
    </item>
    
    <item>
      <title>Plan reporting</title>
      <link>https://step.dev/knowledgebase/30/userdocs/executions/plan-reporting/</link>
      <pubDate>Fri, 21 Nov 2025 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/executions/plan-reporting/</guid>
      <description>In this view, you can find reports aggregated across multiple executions of the same plan. The view shows the same content as the Scheduled Execution Reporting View, but considers both scheduled and manual executions of the selected plan. It can be accessed via the Plan List &amp;ldquo;Open plan report&amp;rdquo; action.</description>
    </item>
    
    <item>
      <title>Event Broker Monitor</title>
      <link>https://step.dev/knowledgebase/30/userdocs/eventbrokermonitor/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/eventbrokermonitor/</guid>
      <description>If you&amp;rsquo;ve purchased the Async package or are running the Premium Enterprise version of Step, you&amp;rsquo;ll be able to monitor in real time what&amp;rsquo;s happening in the EventBroker by navigating to the EventBrokerMonitor view:
The Stats tab provides global statistics on the broker, such as the current amount of messages present in it and the high mark (or water mark), oldest &amp;amp; youngest events, etc.
The next two tabs provide users with the ability to browse and search for events, and organizes the query results either by Id or Group.</description>
    </item>
    
    <item>
      <title>Import/Export entities</title>
      <link>https://step.dev/knowledgebase/30/userdocs/import-export-entities/</link>
      <pubDate>Fri, 02 Oct 2020 08:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/import-export-entities/</guid>
      <description>You may export the following entities:
Plans Keywords Parameters The functionalities are similar for all supported types of entities.
Export Export a single entity Export can be performed from the related table views using the actions buttons. For plans, single entity can also be exported from the Plan editor, click on the export button as shown in the following screenshot:
Export all entities of one type Step also lets you export all entities of one type.</description>
    </item>
    
    <item>
      <title>Analytics</title>
      <link>https://step.dev/knowledgebase/30/userdocs/analytics/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/analytics/</guid>
      <description>Step collects performance data — measurements and metrics — from every execution and makes it available in multiple ways:
Execution and cross executions reports: through the charts, statistics tables and embedded analytics dashboards as detailed measurements and metrics list for each keyword execution in the report details Performance and Metric assertions - the collected measurements and metrics are available as well for: Performance Assertion can be defined in plan and assert collected measurements during the execution of the plan Metric Assertion can be used in assertion plan to evaluate the success of schedule over a series of executions Analytics dashboards: standalone dashboards for cross-execution analysis, scheduling health, grid monitoring, and custom investigations.</description>
    </item>
    
    <item>
      <title>Scheduled execution reporting</title>
      <link>https://step.dev/knowledgebase/30/userdocs/executions/schedule-executions-reporting/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/executions/schedule-executions-reporting/</guid>
      <description>In this view, you can find reports aggregated across multiple executions of the same schedule. The main purpose of this view is to provide insights into whether scheduled executions have passed or failed over time.
Schedule Name – The name of the scheduled task. Use quick-actions to configure the associated plan or schedule. Last Execution – The most recent time the schedule was executed and its result (pass/fail). The settings for automatic refresh and the time range to be shown.</description>
    </item>
    
    <item>
      <title>User account</title>
      <link>https://step.dev/knowledgebase/30/userdocs/userpreferences/</link>
      <pubDate>Sun, 29 Nov 2020 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/userpreferences/</guid>
      <description>User Settings Credentials and preferences can be defined from the User Settings page. Click on your username on the top right box, then on &amp;ldquo;User Settings&amp;rdquo;: User Credentials and API keys On the &amp;ldquo;User Settings&amp;rdquo;, you can modify your password as well as generate and revoke Api keys.
Generate an API Key API keys are used to authenticate with Step when accessing the Step API, whether through direct REST calls, the Step client, or the CLI.</description>
    </item>
    
    <item>
      <title>Versioning</title>
      <link>https://step.dev/knowledgebase/30/userdocs/versioning/</link>
      <pubDate>Sun, 29 Nov 2020 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/versioning/</guid>
      <description>Versioning is a feature to restore a previous version of an entity in Step Enterprise. This can be helpful to undo unintended changes or to revert a breaking change.
How versioning works in Step Versioning is currently supported for the following entities:
Plan Parameter Step automatically saves changes to these entities, aggregated to 1-minute intervals. This aggregation ensures, that a lot of small changes within a minute will only show as one change in the version history.</description>
    </item>
    
    <item>
      <title>Live Reporting</title>
      <link>https://step.dev/knowledgebase/30/userdocs/live-reporting/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/live-reporting/</guid>
      <description>Live Reporting allows to obtain keyword data such as measurements, metrics, or attachments (for instance log files) in real time, while a keyword is running. Introduced in Step 29 for K6 and custom Java keywords, Live Reporting will see further improvements, such as .Net and nodeJS keywords support, in upcoming Step versions.
Overview Traditionally, all keyword results, such as attachments or measurements, are gathered while a keyword is running, then returned once the execution is finished.</description>
    </item>
    
    <item>
      <title>Bookmarks</title>
      <link>https://step.dev/knowledgebase/30/userdocs/bookmarks/</link>
      <pubDate>Fri, 10 May 2024 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/userdocs/bookmarks/</guid>
      <description>Create bookmarks to easily reach frequently used pages over different projects
Creating bookmarks (1) Navigate to any Step page that is frequently used by clicking the bookmark icon while the page is open. Select a name that describes the Project / Page combination.
Manage bookmarks (2) Remove or rename bookmarks
Open bookmark (3) Click the bookmark under the bookmarks category to open the page in the correct project</description>
    </item>
    
    <item>
      <title>Libraries</title>
      <link>https://step.dev/knowledgebase/30/libraries/</link>
      <pubDate>Wed, 13 Feb 2019 00:00:00 +0000</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/libraries/</guid>
      <description>In the enclose pages, you&amp;rsquo;ll find all sorts of information contributed by our development and consultancy teams as well as contributions from the community which we&amp;rsquo;ve compiled and made available for others to use.</description>
    </item>
    
  </channel>
</rss>
