<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Developer guide on Step Documentation</title>
    <link>https://step.dev/knowledgebase/30/categories/developer-guide/</link>
    <description>Recent content in Developer guide on Step Documentation</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en</language>
    <lastBuildDate>Wed, 03 Jun 2026 11:00:00 +0200</lastBuildDate><atom:link href="https://step.dev/knowledgebase/30/categories/developer-guide/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Step AI Ecosystem</title>
      <link>https://step.dev/knowledgebase/30/ai/ecosystem/</link>
      <pubDate>Wed, 03 Jun 2026 00:00:00 +0000</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/ai/ecosystem/</guid>
      <description>In short The Step AI Ecosystem extends the Software Automation as Code approach with autonomous software testing capabilities powered by large language models (LLMs) and AI agents. The Step platform unifies AI-driven functional testing, load testing, and monitoring while integrating seamlessly into existing CI/CD and DevOps workflows.
The Step AI Ecosystem is built on three layers:
Step MCP Server for connecting AI assistants and coding agents to Step Reusable Testing Skills for packaging Step testing expertise into reusable workflows Step Testing Agent for generating, executing, self-healing and validating tests on Step Together, these capabilities enable agentic testing workflows that accelerate test creation, reduce maintenance effort, and improve automation reliability.</description>
    </item>
    
    <item>
      <title>Automation as Code</title>
      <link>https://step.dev/knowledgebase/30/devops/automation-as-code/</link>
      <pubDate>Wed, 21 Aug 2024 00:00:00 +0000</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/automation-as-code/</guid>
      <description>Step&amp;rsquo;s unique Software automation as Code approach (short Automation as code) enables developers to define software automation workflows for the whole DevOps lifecycle as code alongside the product code.
This concept is the key enabler for shift-left in not just testing but for all disciplines relating to software automation. This ranges from large scale E2E acceptance tests to load and performance tests, synthetic monitoring, RPA, and much more.
This pages presents the use-cases enabled by the Automation as Code approach.</description>
    </item>
    
    <item>
      <title>Automation Packages</title>
      <link>https://step.dev/knowledgebase/30/devops/automation-packages-overview/</link>
      <pubDate>Wed, 22 May 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/automation-packages-overview/</guid>
      <description>The concept of Automation Packages provides a standard for defining software automation workflows for the whole DevOps lifecycle in a unified way. Following the Automation as Code paradigm, it allows developers to define software automation logic as code alongside the actual application&amp;rsquo;s code, and provide all the means to execute and deploy this logic at the different stages of the DevOps lifecyle.
Technically the Automation Package standard consist of:
The Automation Package syntax that defines a standard to describe a wide range of automation workflows in a unified way The Automation Package format that defines a standard for packaging entities (like Keywords, Plans, Resources, data, etc) The Automation Package CLI that allows to build, execute and deploy Automation Packages Automation Packages in a nutshell In a nutshell an Automation Package is a self-contained set of Plans and their related entities (Keywords, Parameters, Resources&amp;hellip;) that can be executed on a Step controller or deployed to it for later use.</description>
    </item>
    
    <item>
      <title>Development Overview</title>
      <link>https://step.dev/knowledgebase/30/devdocs/dev_overview/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devdocs/dev_overview/</guid>
      <description>In these sections, you&amp;rsquo;ll get to know how to develop Keywords, as well as how to extend and customize Step using our APIs.
API Description and links Keyword Development Before jumping into the Keyword API details, get to understand the concept of keyword development Keyword API To develop keywords you should refer to our Keyword API page and may follow our tutorials Automation as code Automation as code enables developers to define software automation workflows for the whole DevOps lifecycle as code.</description>
    </item>
    
    <item>
      <title>Automation Package Descriptor</title>
      <link>https://step.dev/knowledgebase/30/devops/automation-package-yaml/</link>
      <pubDate>Wed, 22 May 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/automation-package-yaml/</guid>
      <description>Automation Packages are defined in a declarative way using YAML alongside the automation code. The Step Automation Package YAML syntax is specified by the Automation Package JSON schema, for more convenient work you can configure the embedded file editor in your IDE (IntelliJ IDEA or Visual Studio) to associate this schema with the Step YAML automation packages.
For Java Automation Packages, it is possible to directly declare certain entities in the code in addition to the YAML descriptor.</description>
    </item>
    
    <item>
      <title>Maven plugin</title>
      <link>https://step.dev/knowledgebase/30/devops/automation-package-cli/ap-maven-plugin/</link>
      <pubDate>Wed, 22 May 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/automation-package-cli/ap-maven-plugin/</guid>
      <description>The Step Maven plugin serves as Command Line Interface (CLI) for all operations related to Automation Packages in Java. It provides an integration with the Step server and an easy way to integrate Step with a CI/CD pipeline. For non-Java projects, it is recommended to use the Step CLI.
The Step Maven plugin supports following operations:
Upload Automation Packages to Step and execute them in isolation Deploy the content of Automation Packages to Step and enable the contained schedules Deploy an Automation Packages library to Step You can choose to integrate the plugin goals during the package phase or any later phase as you see fit in the Maven Lifecycle.</description>
    </item>
    
    <item>
      <title>Keyword Development</title>
      <link>https://step.dev/knowledgebase/30/devdocs/keyword-development/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devdocs/keyword-development/</guid>
      <description>Keywords are the fundamental building blocks of Plans. They encapsulate the automation logic and can represent fully automated flows or finer-grained actions, such as single user interactions or service calls.
While Step integrates with a wide range of automation tools and frameworks (like Cypress, K6, SoapUI, etc.) natively through plugin based keyword, it also supports custom keyword development for seamless integration with any others frameworks (Playwright, Selenium, Appium, ect.) thanks to the Step&amp;rsquo;s keyword API.</description>
    </item>
    
    <item>
      <title>Automation Package Libraries</title>
      <link>https://step.dev/knowledgebase/30/devops/automation-package-libraries/</link>
      <pubDate>Mon, 24 Nov 2025 00:00:00 +0000</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/automation-package-libraries/</guid>
      <description>Overview Automation Package Libraries (AP Libraries) extend Step’s Automation Package model by enabling common code, libraries and entities to be packaged, deployed, and referenced independently from individual Automation Packages (APs).
They offer a structured mechanism for sharing logic at scale and optimizing performance across large automation ecosystems.
AP Libraries are reusable, versioned code artifacts that can provide:
Shared logic across multiple Automation Packages Common utilities and helper classes Shared libraries Shared AP entities (Keywords, Plans) Important:</description>
    </item>
    
    <item>
      <title>Automation Packages Multi-version support</title>
      <link>https://step.dev/knowledgebase/30/devops/automation-package-multi-version/</link>
      <pubDate>Fri, 21 Nov 2025 07:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/automation-package-multi-version/</guid>
      <description>Overview Step allows deploying multiple versions of the same Automation Package on a single Step instance. This is particularly useful when your system under test (SUT) exists in several versions across different environments (e.g., TEST, QA, PROD), each requiring a matching version of the automation code.
Multi-version support enables:
several versions of the same package to coexist automatic version selection at runtime consistent usage of keywords and plans from the selected version clear and predictable behavior across environments Step determines the correct version using activation expressions associated with each deployment.</description>
    </item>
    
    <item>
      <title>Step CLI</title>
      <link>https://step.dev/knowledgebase/30/devops/automation-package-cli/step-cli/</link>
      <pubDate>Wed, 22 May 2024 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/automation-package-cli/step-cli/</guid>
      <description>The Step CLI (Command Line Interface) is used for all operations with Step. It provides an integration with the Step server and an easy way to integrate Step with a CI/CD pipeline. Currently it is limited to the operations related to Automation Packages but might be extended in the future. For Java specific projects, the CLI is also available as a Maven plugin.
The Step CLI supports following operations for Automation Packages:</description>
    </item>
    
    <item>
      <title>Keyword API</title>
      <link>https://step.dev/knowledgebase/30/devdocs/keywordapi/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devdocs/keywordapi/</guid>
      <description>For a better understanding of the key concepts and best practices of keywords development, make sure to read first the Keyword development page.
The versatility of Step and its keyword API allows developers to implement their own custom Step&amp;rsquo;s Keywords whether they use 3rd party automation framework or their own libraries.
The Keyword API defines a clear interface to:
define and configure Keywords access Keyword inputs, session objects, and report data (keyword outputs, performance measurements, attachments) implement hooks related to keyword executions (interceptors, error management) The Keyword API is natively available for Java, .</description>
    </item>
    
    <item>
      <title>Automation Package in Java</title>
      <link>https://step.dev/knowledgebase/30/devops/automation-package-java/</link>
      <pubDate>Wed, 22 May 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/automation-package-java/</guid>
      <description>Automation package entities can be defined in a declarative way with the automation package descriptor (YAML) as well as directly in the code for Java Automation Packages. This page focuses on the declaration of Automation Package entities in the code which is supported for Keywords and Plans.
Declaration of Keywords In addition to the declaration of Keywords in the automation package descriptor (YAML), Automation packages also fully support the Keyword API to declare Keywords directly in Java.</description>
    </item>
    
    <item>
      <title>Step client API</title>
      <link>https://step.dev/knowledgebase/30/devdocs/stepclient/</link>
      <pubDate>Wed, 22 May 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devdocs/stepclient/</guid>
      <description>The Java APIs and libraries (step Client) discussed in this section are currently only available in the step Enterprise Edition Introduction The Step client exposes means to connect to the controller programmatically, access and use Step services in a headless way. It also allows to execute locally Step controller functionalities like building and running a plan.
Resources: The Javadocs of the Step client is available here: step.client.StepClient and examples can be found on github.</description>
    </item>
    
    <item>
      <title>REST API</title>
      <link>https://step.dev/knowledgebase/30/devdocs/rest-api/</link>
      <pubDate>Sat, 12 Jun 2021 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devdocs/rest-api/</guid>
      <description>Introduction While you can use the step client to interact programmatically with Step, it is also possible to use the Step&amp;rsquo;s REST API directly.
Note that the service signatures are more likely to change compared to the step client Documentation You will find the documentation of the REST API under the help menu of Step The documentation page provide the detailed specification of every services and means to directly invoke and test the service.</description>
    </item>
    
    <item>
      <title>Event Broker API</title>
      <link>https://step.dev/knowledgebase/30/devdocs/eventbrokerapi/</link>
      <pubDate>Wed, 22 May 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devdocs/eventbrokerapi/</guid>
      <description>The Java APIs and libraries discussed in this section are currently only available in Step Enterprise Edition EventBroker The EventBroker Service and API allow asynchronous communication to happen in Step as well as synchronization between keywords, between plans and between keywords and plans. It is particularly useful in scenarios where a thread (or a &amp;ldquo;user&amp;rdquo;) needs to wait for specific events before performing the next task.
These events can be created internally (from within a keyword or plan) using various types of clients (Java, REST, prepopulated Keywords and Artefacts).</description>
    </item>
    
    <item>
      <title>AI</title>
      <link>https://step.dev/knowledgebase/30/ai/</link>
      <pubDate>Wed, 03 Jun 2026 11:00:00 +0200</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/ai/</guid>
      <description>This section is dedicated to AI-powered testing with Step. It covers the technologies, workflows, and capabilities that enable autonomous software testing across functional testing, load testing, and monitoring. Whether you are exploring AI-assisted test development through the Step MCP Server, leveraging Reusable Testing Skills, or adopting the Step Testing Agent, this documentation explains how Step integrates large language models (LLMs) into existing testing and CI/CD workflows. The goal is to help teams accelerate automation creation, reduce maintenance effort through self-healing capabilities, and deliver reliable, reproducible testing outcomes at scale.</description>
    </item>
    
    <item>
      <title>Automation Package CLI</title>
      <link>https://step.dev/knowledgebase/30/devops/automation-package-cli/</link>
      <pubDate>Wed, 21 Aug 2024 00:00:00 +0000</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/automation-package-cli/</guid>
      <description>Automation Packages come with a full-featured CLI that allows to build, execute and deploy Automation Packages. The CLI is available as native application for Windows and Linux, and as Maven plugin which is recommended for integration with Java projects.</description>
    </item>
    
    <item>
      <title>DevOps</title>
      <link>https://step.dev/knowledgebase/30/devops/</link>
      <pubDate>Thu, 28 Feb 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/</guid>
      <description>This section is dedicated to use of Step in the DevOps context. It targets developers who want to define their software automation artifacts for the whole DevOps lifecycle as code alongside their product code.</description>
    </item>
    
  </channel>
</rss>
