What this is

A practical, build-along session. You bring a laptop and a Robot Framework project (we'll supply one if you don't). You leave with an agentic engineering workflow you can use Monday morning.

The problem we're solving

Test automation eats time in predictable ways: writing the same locator boilerplate, hunting down why a test broke at 3 a.m., updating suites every time the front end changes. Coding agents could take that load off — but only if they speak Robot Framework natively. Out of the box, they don't. We close that gap.

What we'll cover

• Robot Framework MCP — The Model Context Protocol server that gives an agent real, structured access to your RF environment: libraries, keywords, running state, the page under test. No more guessed keywords.
• Agent Skills — Packaging RF know-how so an agent applies your patterns, not generic ones. Composable, shareable, version-controlled.
• Hooks — Intercepting and shaping agent behaviour at the right moments. Guardrails, validation, automatic context.
• Subagents — Splitting big jobs across focused agents instead of one overloaded generalist.
• Natural prompt automation — Describe a test in plain language, get a working .robot suite that follows your conventions.
• Natural prompt debugging — Hand a failing run to an agent and let it trace the cause, propose a fix, and explain its reasoning.
• Self-healing tests — Locators that adapt when the UI moves, so a button relabel doesn't sink your pipeline.
• CI integration — Running agentic flows in your pipeline: where agents help, where humans stay in the loop, and how to keep it deterministic enough to trust.
• Tool integration — Connecting the workflow to GitHub (PRs, reviews, issues) and Jira (tickets, traceability), so automation lives where your team already works.

Who it's for

Test engineers, QA professionals, and automation developers who already know Robot Framework basics and want to see what agents can genuinely add — beyond the hype.

What you need

• Working Robot Framework knowledge (you can write and run a suite)
• A laptop with Python and Robot Framework installed
• A coding agent of your choice (setup guide sent before the session)

What you'll walk away with

A configured agentic setup, a self-healing demo suite, a CI integration you understand top to bottom, and a clear sense of where to trust an agent and where to keep your hands on the wheel.

The Swiss Army knife of automation just got a co-pilot. Let's build it together.

Extending Robot Framework (Advanced)

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 modify tests dynamically before or during execution, and how to analyze results.

This workshop is for you if you already know the 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 chance to ask hard questions related to Robot Framework from its creator.

Key takeaways:

• Extend Robot Framework with custom Python libraries
• Use advanced library APIs (dynamic libraries, type conversion)
• Integrate using Listener and Parsing APIs
• Modify tests dynamically before or during execution
• Analyze and customize test results programmatically
• Gain deep understanding of Robot Framework's internals and extensibility
• Hands-on experience directly from the framework's creator

Knowledge level

Robot Framework: Intermediate knowledge and experience required — comfortable writing and structuring test suites and using basic library APIs

Python: Basic knowledge required — functions, modules, and classes

Prerequisites & technical setup

• Python 3.10 or newer. Python 3.8 or 3.9 will work if you cannot upgrade.
• Robot Framework 7.4.1. Earlier Robot Framework 7.5 versions will work, but you cannot run all examples.
• Editor or IDE that supports Python and Robot Framework. VSCode or PyCharm with the RobotCode plugin is recommended.
• Suitable admin rights to install additional Python modules if needed.

The workshop repository will be provided in advance. The recommended approach is cloning the repository using git, but you can also download the content as a zip file. During the day Pekka will push changes to the main branch, which you can pull to your local repository as needed.

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

Robot Framework in CI/CD Pipelines with Docker

Run your Robot Framework tests anywhere, the same way, every time. In this workshop participants build a containerised test runner — a Docker image with a single entry point that becomes the unit of portability across every CI system. Start the application under test, run the container, and collect results.

We start from a painful "business-as-usual" pipeline and diagnose why it hurts, design a clean CI/CD setup with testing as a first-class citizen, and then go hands-on: running the suite locally with Docker Compose, scaling it out with parallel and cross-browser execution, wiring up aggregated reporting and the Robot Framework Dashboard, and proving the approach is genuinely tool-agnostic by connecting the identical runner to both GitLab CI and other tools.

Everything is demonstrated against a small provided demo application with both a web UI and a REST API. It will be ready to use approach that could be applied and scaled in every project.

Key takeaways:

• Build a tool-agnostic, Docker-based runner that executes Robot Framework tests the same way everywhere, with no CI vendor lock-in
• Run containerised test execution: parallel and distributed runs, cross-browser matrices, and a clean environment-variable contract
• Produce efficient, aggregated reporting with JUnit, the Robot Framework Dashboard, Allure, ReportPortal, and GitLab Pages
• Write parallel-safe test suites that don't collide on shared application state

Knowledge level

Robot Framework: Intermediate knowledge and experience required — comfortable writing and structuring test suites and running them locally

Docker: Basic working knowledge required — able to run docker and docker compose commands; image-building concepts are explained

CI/CD: Basic familiarity helpful — exposure to any pipeline tool (GitLab, GitHub Actions, Jenkins) is useful but not mandatory

Git: Working knowledge required — branching, commits, merge requests

Command line: Basic proficiency

Agenda

DevOps & CI/CD Foundations

• Definitions and terms: CI, CD (delivery vs. deployment), pipelines
• The business-as-usual case: typical pain points and root-cause analysis
• Why vendor-coupled tests hurt

Designing a Clean CI/CD

• Branching, artifacts, and quality gates
• Environments, releases, and rollbacks
• Monitoring and measurements
• The dream pipeline

The Tool-Agnostic Docker Pattern

• The runner image and the environment-variable contract
• The three responsibilities of any CI adapter
• Building and running the runner image
• Containerised execution with docker compose run

Scaling Execution

• Pabot processes; suite-level vs. test-level parallelism
• Cross-browser matrix (Chromium, Firefox, WebKit)
• Writing parallel-safe suites
• Downstream and multi-project pipelines

Efficient Reporting

• JUnit for native CI test tabs
• Robot Framework Dashboard (multi-run trends)
• Allure and ReportPortal
• GitLab Pages and log artifacts

Connecting Any CI Tool

• GitLab CI worked example
• Smart test selection: tag/branch selection, change-based runs, caching, fail-fast

Prerequisites & technical setup

Computer capable of running Docker, with internet access

Software:

• Docker and Docker Compose (the primary requirement; the runner image bundles everything else)
• Git
• Editor with Robot Framework support (e.g. VS Code with the RobotCode plugin recommended)
• Optional, for the no-Docker local path: Python >= 3.8, NodeJS 18 or 20, Robot Framework >= 6.1, Robot Framework Browser >= 18

GitLab account (free tier sufficient) — used for the worked example

GitHub account — for the GitHub Actions adapter and examples

The workshop repository will be provided in advance, including the demo app, parallel-safe test suites, the Docker runner, the GitLab pipeline, and a GitHub Actions adapter

We will provide a sample test case and a setup-verification step to confirm your environment. The fastest check is make docker-build

Agenda

1. Introduction (30 min.)

   • Who are you?
   • Why robosapiens?
   • Hello robosapiens
     • 32-bit vs 64-bit
     • Presenter mode

2. Keywords and locators (5 hours)

   • Open and Close SAP
   • Connect and disconnect from a server
   • Connect to a running SAP GUI
   • Execute a transaction
   • Form fields:
     • Text fields (single-line and multiline)
     • Labels, tooltips, no labels and non-unique labels
     • Buttons
     • Checkboxes
     • Radio buttons
     • Combo boxes
     • Tabs
     • Ad-hoc grids

   COFFEE BREAK (10 min.)

   • Scrolling
   • Tables:
     • Text fields
     • Buttons
     • Checkboxes
     • Radio buttons
     • Combo boxes
     • Columns and Rows
     • Multiple tables
     • Non-unique column titles
     • Export to Excel
   • Trees:
     • Tree elements
     • Context menus
     • Export to JSON
   • ABAP Lists

   LUNCH BREAK (40 min.)

   • Key combinations
   • Menus
   • Toolbars
   • Statusbar
   • Screenshots
     • Manual
     • Automatic with a Listener
   • Windows
     • Window title and contents
     • Maximize and close a window
     • Multiple windows
     • Pop-up windows
     • Export to JSON

   COFFEE BREAK (10 min.)

3. Automate your own process (2 hours)

   • Recording:
     • robosapiens mode
     • domain-keyword mode

4. Feedback (30 min.)

Prerequisites and Technical Setup

• SAP Server with Scripting Support enabled
• SAP GUI 8 for Windows that can connect to the SAP Server
• A process you want to automate in the SAP GUI
• Latest version of robotframework-robosapiens
• Latest version of robotframework-debug
• VS Code with RobotCode

See the repository: https://github.com/imbus/robotframework-robosapiens