World Wide Workshop Wednesday 2025

Target Audience: Test Engineers with Robot Framework experience

Workshop Content:

• robotframework-aiagent library:
  • Natural language test execution
  • AI-assisted test generation
  • Image analysis
  • Document processing
  • Text recognition and content analysis
  • Structured data extraction
    • AI provider integration: configuring OpenAI, Anthropic, Mistral, self-hosted cloud models, and local AI models
    • Multi-model workflows: using specialized models for specific tasks and seamless conversation handoffs between different AI providers
    • Developing custom AI tools for specific testing requirements
    • MCP server integration for contextual AI assistance
• RobotCode extension AI features, GitHub Copilot optimization and VS Code workspace configuration for AI-enhanced Robot Framework development
  • AI-assisted test case generation and execution
  • Optimizing project management with AI tools
  • Enhancing test creation and maintenance workflows
  • Error detection and debugging with AI support
  • Automated test case generation with AI
  • Converting AI insights into improved automated test cases

Hands-On Labs:

• Setting up robotframework-aiagent with multiple AI providers and MCP server configuration
• Creating custom AI tools for specialized testing scenarios
• Building AI-enhanced test suites with image analysis and document processing
• Configuring RobotCode extension AI features and optimizing Copilot for Robot Framework
• Multi-model workflows: orchestrating different AI models for specific tasks

Join René for a hands-on deep dive into best practices for building and maintaining Robot Framework libraries. Drawing from real-world experience in customer projects and core development of the Browser library, this workshop distills years of lessons into a practical and applicable format.

Topics Covered:

• Dynamic Library API Learn how Robot Framework dynamically interacts with Python libraries using the Dynamic Library API. You'll understand how keywords are discovered and executed at runtime—key knowledge for building flexible, or more complex libraries.

• Library Structuring with PythonLibCore (DynamicCore) Discover how to use the DynamicCore base class from PythonLibCore to build modular and maintainable libraries.

  • Structure keywords into sub-classes for better organization and separation of concerns
  • Add metadata like tags and documentation dynamically
  • Improve code reuse and testability in larger libraries

• Assertion Engine Integration Learn how to integrate Robot Framework Assertion Engine for writing expressive and consistent verifications. This avoids scattered BuiltIn calls and helps you centralize validation logic with readable failure messages.

• Type Hints and Argument Typing Use Python’s type hints to improve readability, maintainability, and IDE support.

  • Define argument and return types in your keyword methods
  • Understand Robot Frameworks automatic type conversion logic
  • Help users (and yourself) avoid runtime errors by making intent clear

• Custom Type Converters Extend Robot Framework's argument parsing by registering custom converters.

  • Convert strings or other types from test cases into domain-specific Python types
  • Improve keyword usability and reduce repetitive parsing logic
  • Introduce type documentation

• Linters, Formatters, and Pre-Commit Hooks Enforce code quality and style automatically:

  • Use tools like ruff and mypy to catch errors early
  • Set up pre-commit hooks to keep your code clean and consistent
  • Learn how to configure and integrate them into your library workflow

Who is this for?

This workshop is aimed at developers who:

• Have basic Python knowledge
• Understand how to create Robot Framework libraries
• Want to raise the quality, maintainability, and clarity of their libraries

Whether you're starting a new library or maintaining an existing one, you'll come away with the tools and patterns to build libraries that are robust, well-structured, and easy to use.

Workshop Description

The workshop includes walking through:

• Creating a basic project structure
• Generating the OpenAPI client in Python
• Creating keywords in Python and Robot Framework for connecting / controlling the API, DB and web frontend
• Implement some basic test cases

After accomplishing the mentioned steps with trainer guidance and support, the workshop continues with more advanced exercises.

Knowledge Level

Intermediate. Participants are expected to have at least basic knowledge of Robot Framework and Python. Basic experience with SQL, REST API and Docker is nice to have.

Technical requirements

The comprehensive list of technical requirements will be provided later on. Roughly, participants would need a computer with following software and libraries installed:

• Editor / IDE, e.g. VS Code
• Python
• RF
• Browser Library
• Database Library
• Docker - an image with SUT installed will be provided later on

Probably, an alternative workspace in a web based IDE like GitPod might be provided.

In this workshop you will learn how to extend Robot Framework using various different interfaces using Python. The first half of the workshop is dedicated to the more advanced parts of the library API such as automatic argument type conversion and the dynamic library interface that is used, for example, by SeleniumLibrary. During the second half you will get familiar with other extending and integration possibilities such as the listener API, the parsing API, how to modifying tests dynamically before or during execution execution and how to analyze results.

This workshop is for you if you already know basics of using Robot Framework, including basics of the library API, and want to take your skills to the next level. These skills make it easier to adapt the framework to your own needs in different contexts. In addition to knowing Robot Framework, participants are expected to know basics of Python programming such as functions, modules and classes.

The workshop is 100% hands-on, no slides, learn-by-doing. In addition to learning from the person who has designed these powerful APIs, you have a change to ask hard questions related Robot Framework from its creator.

Description

Unlock the power of Robot Framework’s lesser-known dynamic and hybrid library APIs.

As automated testing scales across large, integrated systems, test frameworks must strike a balance between clean usability for testers and modular maintainability for developers. In this workshop, we’ll explore how Robot Framework’s dynamic library API enables just that.

Imagine testing dozens of RESTful services: user, orders, payments and many, many more. You also need to deal with authentication & authorization. With static libraries, you'd need a tangle of imports and exposed implementation details in every test suite. Instead, we’ll show how to build a single, unified RF library that dynamically loads service-specific Python modules at runtime. This allows test authors to use concise, readable test cases like Create New User or Verify Payment Received through one import, regardless of where the logic lives under the hood.

You’ll learn when and why to choose dynamic (or hybrid) libraries over static ones, how to implement them cleanly, and how this approach empowers cross-functional teams to scale their test automation without creating a mess.

This workshop is designed for test engineers and automation developers who want to move beyond simple static libraries and build flexible, scalable, and maintainable keyword libraries. Through a hands-on example based on REST API testing, you’ll learn how dynamic libraries work under the hood, when and why to use them, and how to structure Python-based libraries that expose clean, unified interfaces to test authors.

Key Takeaways

• Understand the differences between static, dynamic, and hybrid libraries in Robot Framework.
• Learn when and why to use dynamic or hybrid libraries in real-world test automation projects.
• See how Robot Framework discovers and executes keywords at runtime through the dynamic and hybrid API.
• Build maintainable dynamic and hybrid libraries that pulls together multiple Python modules under one import.
• Write clean, high-level test cases while keeping the complexity hidden in well-structured code.

Knowledge Level

• Robot Framework: Intermediate (understanding of test case syntax, keyword usage, and test suite structure)
• Python: Intermediate (modules, classes, methods, basic Python syntax)
• HTTP/REST APIs: Basic understanding of REST concepts and HTTP verbs (GET, POST, PUT, DELETE)
• Python Requests Library: Preferable, but not required (we will walk through usage in examples)

Agenda

1. Introduction

• 1.1 Why RF scripting isn't always enough
• 1.2 Introduction to the RF library APIs: Static vs. Dynamic vs. Hybrid
• 1.3 Taking a peek under the hood

2. Use Case: REST API Testing Framework

• 2.1 Overview of the demo application (multi-service REST API)

3. Static Library

• 3.1 Build the library
• 3.2 Using the Library in Tests
• 3.3 Limitations of the static approach

4. Building a Dynamic Library

• 4.1 Implementing get_keyword_names() and run_keyword()
• 4.2 Aggregating keywords from multiple modules
• 4.3 Structuring for maintainability
• 4.4 Using the Library in Tests

5. Building a Hybrid Library

• 5.1 Reuse our static library
• 5.2 Implementing get_keyword_names() and getattr()
• 5.3 Using the Library in Tests

6. PythonLibCore

• 6.1 Using DynamicCore and HybridCore
• 6.2 Easy Library Structuring with PythonLibCore

Preparation and Technical Requirements

• Computer: Capable of running Python 3 and Robot Framework with internet access

• Software:

• Python >= 3.8

• Robot Framework >= 6.1

• Editor: Any Python/RF-compatible IDE (VSCode recommended)

• Optional Tools: curl or Postman (for exploring APIs)

• Accounts: None required (public API will be used)

• Test Setup: A GitHub repo or downloadable ZIP will be provided with the project structure and stub code

Workshop Description In this workshop, you'll learn how to effectively manage and test cloud-native applications with a focus on the layers beneath the application itself—deployment, runtime, and configuration.

We'll explore essential tools in the cloud-native toolbox, including kubectl, Helm, and Terraform, to understand how applications are deployed and run on Kubernetes.

Once we've established a working application in the cluster and a good grasp of its environment, we'll shift our focus to automation. You'll learn how to use Robot Framework, along with the KubeLibrary and TerraformLibrary, to turn your manual deployment and validation steps into robust, repeatable test automation.

Knowledge Level A keen interest in cloud-native applications, Kubernetes and Terraform is required. Existing knowledge in Robot Framework will be helpful.

Workshop Agenda The first half of the workshop will be about understanding Kubernetes, using kubectl and Helm. We'll deploy a cloud-native application and analyse its configuration. In the second half we'll start automating using the KubeLibrary as well as Terraform via the TerraformLibrary.

Preparation and Technical Requirements You can bring your own Kubernetes cluster. But we can also work with a locally installed cluster via KinD (Kubernetes in Docker) https://kind.sigs.k8s.io/. Other than that you'll need the following tools installed:

• kubectl
• opentofu or terraform CLI
• Robot Framework
• Helm

Hands-On Taster Experience of Robot Framework Certified Professional Course

Workshop Description Get first-hand experience of Robot Framework and learn what it means to become a certified professional in this hands-on experience where Benjamin will guide you through the Robot Framework Certified Professional course, covering chapters two and three! This workshop has been adapted from an accredited RFCP course and features the same high quality that would be seen in the complete course.

This full day workshop will go through chapters 2 and 3 of the RFCP, namely Getting Started with Robot Framework and Keyword Design, Variables and Resource Files.

Example programs and exercises will be provided to test your knowledge throughout the workshop, and Benjamin will be happy to lend a hand in your learning.

Key Takeaways

• Complete guided coverage of two chapters of the RFCP syllabus
• Example programs that illustrate Robot Framework functionality
• Small tasks to be completed during the workshop to expand your understanding of Robot Framework

Knowledge Level

• Robot Framework: Beginner, no experience required
• Programming: Beginner, minimal experience preferred

Workshop Agenda <ol> <li> RFCP Chapter 2: Getting Started with Robot Framework (3 hours)<br>

• Suite File & Tree Structure<br>
• Basic Suite File Syntax<br>
• Executing Robot<br>
• Keyword Imports<br>
• Keyword Interface & Documentation<br>
• Writing Test | Task and Calling Keywords<p></p> </li> <li> <p>RFCP Chapter 3: Keyword Design, Variables, and Resource Files (3 hours)<br>
• Resource File Structure<br>
• Variables<br>
• User Keyword Definition & Arguments<br>
• Using Data-Driven Specification<br>
• Advanced Importing of Keywords and Naming Conflicts </p> </li> <li> <p>Executable exercises to test your chapters 2 & 3 knowledge (1 hour)</p> </li> </ol> Preparation and Technical Requirements This workshop will be run online and has audio and video components. You will require sufficient internet access and speed to participate in the workshop. You should also have:
• A computer capable of running Robot Framework with internet access
• Software:
  • Python >= 3.10
  • Robot Framework >= 7.0
  • Editor (IDE) for Robot Framework (e.g., VSCode or IntelliJ)
  • Optional: Robot Code plugin for VSCode or IntelliJ
• Test Cases: Provided during the workshop

An installation overview will be provided during the workshop.

The workshop aims to show how to start running parallel test cases with Robot Framework and how to use the more advanced features of Pabot. Basic knowledge of Robot Framework is needed, but no experience with Pabot.

Agenda:

1. What is Pabot
2. Basic usage of Pabot: argument files, test level split, number of processes
3. Ordering the tests
4. Pabotlib features
5. Sharing resources between parallel tests
6. Acquire lock and release lock
7. Q&A

The participants need do have a computer with installed Robot Framework and an IDE in which they like to work.

Workshop Overview:

This comprehensive online workshop provides an in-depth exploration of the latest RobotCode Extension and Command Line Tools, showcasing their practical application in real-world Robot Framework projects. Through interactive demonstrations, live coding sessions, and hands-on exercises, participants will master RobotCode features and best practices to enhance test automation workflows.

Knowledge Level:

• Basic understanding of Robot Framework.
• Familiarity with Python is beneficial but not mandatory.

Workshop Agenda:

1. Installation and Setup of RobotCode:

• Step-by-step installation of the latest RobotCode Extension and CLI tools.
• Configuring VS Code for Robot Framework development.

2. Project Setup with RobotCode:

• Structuring the project for scalability and maintainability.
• Using Python project managers for efficient dependency management.
• Best practices for multi-environment project organization.

3. Exploring RobotCode latest Features:

• Overview of general features that enhance productivity.
• Introduction to new and advanced features.

4. robot.toml Configuration:

• Understanding general configuration settings.
• Creating configuration profiles for different environments.
• Splitting configuration into multiple files for modularity.

5. Command Line Interface (CLI) Tools:

• Retrieving valuable information about your project.
• Analyzing your project to identify improvements.
• Running tests directly from the command line.
• Profile-based execution for different testing scenarios
• Integration with modern Python project tools (pyproject.toml compatibility)
• Configuration inheritance and override strategies

6. ntegrating CI/CD Processes:

• Executing tests within a CI/CD pipeline.
• Debugging test runs in CI/CD environments.
• Project analysis and health reporting with detailed insights
• Automated code quality checks
• Git hooks integration for automated quality gates

Preparation and Technical Requirements:

• Stable internet connection
• VS Code installed
• Access to modern web browser for interactive exercises

A full‑day, hands‑on workshop exploring the Robot Framework Browser library powered by Playwright—with a focus on deep architecture, keyword extensions in JavaScript and Python, and advanced automation techniques.

Join us to elevate your web automation skills through the modern, high-performance Browser library. This workshop gives you the knowledge and practical experience to both use and extend Browser like a pro. Whether you're automating complex workflows or building custom plugin keywords, you'll gain the expertise to architect future‑ready automation frameworks.

Day‑Long Agenda:

1. Architecture Deep Dive

   • Explore the gRPC‑based integration between Robot Framework’s Python side and Playwright’s Node.js engine
   • Understand how Browser handles contexts, pages, selectors, and concurrency

2. Installation & Initialization

   • Setup Python (3.9+), Node.js (18 or 20 LTS), Robot Framework Browser via pip and rfbrowser init
   • Managing browsers, cleaning, and selective installations for efficient CI/CD usage

3. Core Keyword Usage & Logging

   • Navigating Browser, Context, Page keywords
   • Configuring logs, Playwright tracing, assertion patterns, and debugging strategies

4. Selector Strategies & Advanced Waiting

   • Chaining text, css, and xpath selectors
   • Fine‑tuning selection with nth‑child strategies
   • Using Promise To, Wait For, and Network‑idle handling for reliable waits

5. Extending Browser with JavaScript Plugins

   • Build custom keywords in JS
   • Define documentation and integrate into Robot Framework tests seamlessly

6. Python Plugin‑API & Using Browser from Python

   • Write Python‑based extensions
   • Use Browser library programmatically from Python for hybrid automation workflows

7. Advanced Keywords in Action

   • Usage patterns for file uploads, element states, context switching, and promise‑based orchestration
   • Deep dive into the AssertionEngine for testing robustness

8. Real‑World Workshop Labs & Troubleshooting

   • Work through curated scenarios from the robotframework‑browser‑advanced‑workshop repo
   • Interactive labs: create custom plugins (JS + Python), solve flaky test scenarios, optimize selectors and waits

9. Deployment, CI/CD & Tips from the Core Team

   • Best practices in packaging, version updates, Robotidy transforms
   • Streamlining automation pipelines using Browser library efficiently

Who Should Attend?

• Experienced Robot Framework users familiar with SeleniumLibrary or Browser basics
• Test automation engineers or developers wanting to build custom extensions in JS/Python
• Teams looking to scale reliable, modern UI automation using Playwright under the hood

What You’ll Take Away:

• A deep architectural understanding of Browser library and Playwright internals
• Hands‑on experience in authoring custom Browser keywords (JavaScript & Python)
• Mastery of advanced selectors, waits, logging and assertion patterns
• Ready‑to‑use techniques for CI integration, browser binary management, and code transformation

Prerequisites & Tech Setup:

• Python >= 3.9
• NodeJS 20 or 22
• Robot Framework >= 6
• Robot Framework Browser library >= 19.7
• Preferred IDE such as VS Code with Robot Code
• Access to test VM or Gitpod for cloud installation
• GitHub account to access the workshop repo

Workshop Goal:
This workshop will show you how to integrate generative AI (OpenAI and Gemini) with Robot Framework. Together we will create a simple Python library, connect it with Robot Framework, and explore how LLMs can boost your testing workflows.

Key Objectives:

• Learn how to connect Robot Framework with modern AI models
• Generate test documentation and keyword descriptions automatically
• Create dynamic test data on the fly
• Experiment with working files as context for AI
• Understand how to extend Robot Framework with custom Python libraries

Knowledge Level:
Basic Python coding skills and prior experience using Robot Framework. You should be comfortable writing simple functions in Python and running Robot Framework tests. This workshop is aimed at intermediate automation testers and developers who want to explore AI-powered testing.

Workshop Agenda (09:00–17:00):

1. 09:00 – 09:30: Introduction – AI in testing, OpenAI and Gemini models, integration options
2. 09:30 – 11:00: Building a Python Library – Live coding session to create a simple AI-powered library
3. 11:00 – 12:00: Integrating with Robot Framework – Connecting the library to Robot Framework and running tests
4. 12:00 – 13:00: Lunch Break
5. 13:00 – 14:30: Working with Generative AI – Generating test data, documentation, and test cases dynamically
6. 14:30 – 16:00: Hands-on Exercises – Extending the examples and experimenting with custom ideas
7. 16:00 – 17:00: Wrap-up & Q&A – Best practices, limitations, and discussion

Preparation and Technical Requirements:

• Installed Python 3.10+
• Installed Robot Framework
• Basic IDE or editor (PyCharm, VSCode, etc.)
• API keys for OpenAI and Gemini (will be provided by us for the workshop day)