HELSINKI

Helsinki 8–12 March 2027

RBCN27 IN-PERSON

Workshop Day · 9 March

Daniel BiehlDaniel Biehl
Many KasirihaMany Kasiriha

Agentic Engineering with Robot Framework: Teach Your Agent to Test Like Your Team

🔗
Mar 09, 09:00 AM | 8 hrsDaniel BiehlMany Kasiriha

Teach an AI agent to test a native desktop application the way you would. Together with an agent equipped with the open Robot Framework agent plugins, we set up a project with RobotCode and PlatynUI, explore the application, go spec-driven from requirements to traceable test cases, compose test runs and debug failures in their real context – with quality gates on every change and a human in the loop. Along the way you learn context engineering: what belongs in AGENTS.md, in skills and in your project docs, so the agent follows your requirements, standards and processes.

Coding agents can write, run and fix Robot Framework tests – if they understand your application, your requirements, your test approach and standards, your test and CI environments and the way you or your team develops software. Out of the box they guess, and they write tests nobody would accept.
In this workshop we build a real test project from scratch for native desktop UI automation with Robot Framework, RobotCode and PlatynUI – no web app, nothing the agent already knows from its training data. Together with the agent you explore the application, take a spec-driven approach from requirements to test cases with full traceability, compose test runs from your test base and debug failing tests in their real context – always with a human in the loop.

Starting from RobotCode's agent-aware CLI and the open Robot Framework agent plugins, you teach the agent the rest: you write your own skills that capture your test approach and quality standards, your requirements, your test and CI environments, your development process, how to use the Robot Framework libraries you rely on and how the application under test works, and you add hooks that act as quality gates on every change.

Context engineering runs through the whole day: what belongs in AGENTS.md, what in skills and what in your project documentation – and how to keep that context alive as your project grows.

Agenda

What we cover:
• Setting up the project and giving the agent its first context
• Exploring the application under test together with the agent
• Capturing test approach, standards, requirements, environments and process as skills
• Turning the use of a Robot Framework library into a skill
• Spec-driven: from requirements to traceable test cases
• Exploring the test base and composing test runs
• Debugging failing tests together, in their real context
• Organizing and maintaining agent context

You leave with a working project, your own skills and a clear sense of where to trust an agent and where to keep your hands on the wheel. Everything you learn carries over to any Robot Framework library.

Who should attend this workshop
Test engineers, automation developers and test leads who already write and run Robot Framework suites and want an AI agent to deliver tests they would actually accept – in a team or on their own. If you have tried a coding agent and ended up fixing its output, this workshop is for you. You need basic Robot Framework and command-line skills; no desktop-automation experience required.

Technical Requirements
All attendees must provide their own laptop. Full setup instructions will be provide about two week prior to the workshop.

Daniel Biehl
Daniel Biehl
Developer, Opensource enthusiast, Pro in many languages and testing tools, Developer of RobotCode -Robot Framework support for VSCode
Many Kasiriha
Many Kasiriha
Lead Technology Architect at DSV with a focus on QA and AI engineering, father, husband and dog owner, musician, likes farming games but is bad at gardening
Pekka KlärckPekka Klärck

Extending Robot Framework (Advanced)

🔗
Mar 09, 09:00 AM | 8 hrsPekka Klärck

In this workshop you learn how to extend Robot Framework in various ways. We start from the more advanced parts of the library API and also cover other topics such as the listener API, the parsing API, and the execution and result models.

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

These skills make it easier to adapt the framework to your own needs in different contexts. The workshop is 100% hands-on: no slides, just learning by doing. Besides learning from the person who designed these APIs, you get the chance to ask hard questions about Robot Framework from its creator.

Knowledge level: Intermediate to Advanced

This workshop is for you if you already know the basics of using Robot Framework, including the basics of the library API (you have created simple keyword libraries in Python), and want to take your skills to the next level. You should also know Python basics such as functions, modules and classes. The basics of the library API are not covered in the workshop.

Agenda

  1. Libraries: advanced library API, including automatic argument type conversion and the dynamic library interface
  2. Listeners: observing and reacting to test execution with the listener API
  3. Data and result modifiers: modifying tests dynamically before or during execution, and analyzing and customizing results
  4. Parsing API: working with Robot Framework data programmatically

Preparation and technical requirements

  • A laptop with admin rights, so you can install Python modules if needed
  • Python 3.10 or newer
  • The latest Robot Framework version (the exact version will be confirmed before the workshop)
  • The Python-Markdown and Pygments modules
  • An editor or IDE that supports Python and Robot Framework. VS Code or PyCharm with the RobotCode plugin is recommended.
  • Workshop materials will be shared as a GitHub repository before the workshop. Cloning it with git is recommended so you can pull updates during the day, but you can also download it as a zip.
Pekka Klärck
Pekka Klärck
Pekka Klärck is the inventor and lead developer of Robot Framework. He started the project in 2005 as part of his master’s thesis at Helsinki University of Technology (now Aalto University) and has been steering its development ever since. Pekka is known not only for his technical expertise but also for his dedication to fostering an open-source community. He actively collaborates with contributors worldwide and regularly shares his insights at conferences and events.
Tatu AaltoTatu Aalto
René RohnerRené Rohner

Mastering Robot Framework Browser: Extend, Automate, Integrate with Playwright

🔗
Mar 09, 09:00 AM | 8 hrsTatu AaltoRené Rohner

Learn the internals of the Robot Framework Browser library in this advanced hands-on workshop.

Topics include architecture, scopes (browser, context, page), selectors, promises, and tracing.

You'll build and use custom keywords with JavaScript and Python, extend the library via plugins, and explore advanced features of the latest Browser 20 release.

Description

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 with 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.

Agenda:

## 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

### Installation & Initialization
- Install with BrowserBatteries, the recommended way, which bundles a precompiled Node.js so no separate Node.js install is needed
- Alternatively, bring your own Node.js (22, 24 or 26 LTS) and run rfbrowser init
- Python 3.10+ and Robot Framework 7.1.1+
- Managing browsers, cleaning, and selective installations for efficient CI/CD usage

### Core Keyword Usage & Logging
- Navigating Browser, Context, Page keywords
- Configuring logs, Playwright tracing, presenter mode, assertion patterns, and debugging strategies

### 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

### Extending Browser with JavaScript Plugins
- Build custom keywords in JS
- Define documentation and integrate into Robot Framework tests seamlessly

### Python Plugin‑API & Using Browser from Python
- Write Python‑based extensions
- Use Browser library programmatically from Python for hybrid automation workflows

### Advanced Keywords in Action
- Usage patterns for file uploads, element states, context switching, and promise‑based orchestration
- Handling secrets and credentials safely with Robot Framework's Secret type
- Deep dive into the AssertionEngine for testing robustness

### 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

### Deployment, CI/CD & Tips from the Core Team
- Best practices in packaging, version updates, and keeping suites tidy with Robocop
- Streamlining automation pipelines using Browser library efficiently

Tatu Aalto
Tatu Aalto
Tatu Aalto has been doing testing for +25 years and have been part of the Robot Framework ecosystem for +15 years. He maintains several projects in Robot Framework world, mainly focusing on UI automation and library development. He is currently the lead developer of Browser library and SchemathesisLibrary. He currently works at OP where he builds testing capabilities as service and is one of the AI evangelist in the company.
René Rohner
René Rohner
René Rohner brings a wealth of experience in test automation to the forefront of the software testing community. As the Chairman of the Robot Framework Foundation and a key developer of several projects within the Robot Framework ecosystem, including the innovative "Robot Framework Browser," René is dedicated to improving testing practices and methodologies. With a background in consulting and training, his work focuses on practical solutions and tools that address the real-world challenges faced by testers and engineers today. René is also an author and a Principal Consultant at imbus AG in Germany, where he continues to contribute to the field of test automation through his expertise and passion for teaching.
Gerwin LaaglandGerwin Laagland
Oscar van DamOscar van Dam

Keyword Architecture: Building a Shared Language

🔗
Mar 09, 09:00 AM | 8 hrsGerwin LaaglandOscar van Dam

Your keywords make sense to you. Can a colleague predict what they do? In Robot Framework, a project's keyword vocabulary, meanings, and conventions form its own dialect.

In this full-day workshop, work in pairs on a shared case to:
* Agree on meanings and align keyword names, arguments, and behavior.
* Decide when layers help and define responsibilities and dependency rules.
* Refactor when requirements or domain language change.
* Maintain conventions through reviews, linting, and checks.

Leave with methods for developing a shared keyword language that colleagues can learn and use.

Your keywords make sense to you. Can a colleague predict what they do and choose the right one?

Every Robot Framework project develops a dialect: its keyword vocabulary, meanings, and conventions. This full-day, hands-on workshop helps you develop a shared keyword language that colleagues can understand, use, and maintain. The aim is to make that work less dependent on the people who wrote the keywords.

You'll use shared meanings to guide keyword design and architecture, then test your choices through code changes, review, and another person's use of the keywords.

What you'll explore
- Establishing shared meaning. Identify the concepts and actions your keywords represent. Decide where business, application, or technical vocabulary fits the caller's task and the keyword's responsibility. Compare interpretations and resolve ambiguous meanings.
- Designing predictable keywords. Align names, arguments, behavior, outcomes, and failure conditions across related keywords. Check whether another person can predict what a keyword call will do.
- Structuring the project. Decide where responsibilities belong, explore when layers help, and establish boundaries and dependency rules. Explain why the structure fits the project's language and constraints.
- Improving existing code. Assess how changes in requirements or domain language affect keywords, their callers, and the behavior colleagues rely on. Make manageable changes and verify the intended behavior.
- Maintaining conventions. Turn design and architecture decisions into review criteria. Explore linting and other checks, distinguish what needs human judgment, and reconsider conventions as the project develops.
- Helping colleagues learn the dialect. Use examples, pairing, documentation, and review to explain how keywords work and why conventions exist. Check whether someone unfamiliar with the project can find, use, and extend its keywords. Use their feedback to improve keywords and guidance.

How we'll work

You'll work in pairs on a guided case that develops across the six topics. Each block combines inspecting a problem, a focused explanation or demonstration, practice, peer review, and reflection on applying the method in your own work. You'll compare interpretations, explain your choices, check your work against review criteria, and revise where useful.

Different solutions may be appropriate. The aim is to make choices colleagues can understand and review, and refine them as the project changes. You'll leave with methods and review questions you can adapt to your own projects and use with your team to review keywords, agree on conventions, and explain design decisions.

Who it's for

Robot Framework practitioners, especially consultants and test automation engineers. You should be able to read a simple test, understand user keywords with arguments, and understand resource imports. Python knowledge is optional.

Technical Requirements
- Laptop with Python, Robot Framework, and a suitable editor.
- Ability to run a simple Robot Framework test.
- Python programming knowledge is optional.
- Required versions, libraries, and linting tools will be specified in advance setup instructions before workshop.

Gerwin Laagland
Gerwin Laagland
Gerwin Laagland is a test engineer and board member of the Robot Framework Foundation. His work focuses on back-end systems and integrations, using Robot Framework to build and maintain test automation. Alongside project work, Gerwin teaches Robot Framework courses and leads community workgroups on documentation, the Robot Framework Certified Professional (RFCP) syllabus and training accreditation. He enjoys helping colleagues understand the automation they work with and sharing what he learns through teaching and community discussions.
Oscar van Dam
Oscar van Dam
Oscar van Dam is a Test Automation Engineer with five years of experience working with Robot Framework. His work has primarily focused on UI test automation, with additional experience in API and database testing. Over the years, he has developed a particular interest in keyword design and project architecture, with a focus on building maintainable and well-structured test automation projects. He enjoys exploring ways to make test automation easier to understand, use, and maintain.
Arttu TaipaleArttu Taipale

Hardware testing and Robot Framework

🔗
Mar 09, 09:00 AM | 8 hrsArttu Taipale

"We want Robot Framework training - but can it please be something else than web validation?"

A customer prospect contacted us like this, seeking a training for their company's test automation team who wanted to move on to Robot Framework. Most tutorials work on systems under test that are easy to manage, use and distribute. It makes sense from the point of view of learning the framework, but what about learning the skills, opportunities, details and pitfalls of testing a "real world" system? Join me for a day's workshop on building, testing and validating hardware - with Robot Framework!

Hardware testing with Robot Framework

Robot Framework is a generic automation framework suitable for many topics, but especially beginner-level tutorials focus more than often on web validation. This makes sense for many purposes, but the lack of a holistic tutorials for basic hardware testing may result in Robot Framework not being utilized highly in an area where it excels just as much as in other fields of testing. By combining hardware-level understanding of the system under test (SUT) and basic usage of Robot Framework and python in a single workshop, we can pave the way for a more global understanding of how to incorporate Robot Framework into hardware testing.

Agenda

The workshop will follow the structure of the ISTQB generic Test Automation Architecture in the sense that we build up from having a system under test, then building the adaption layer, and finally connecting Robot Framework to that adaption layer.

  1. Building a System Under Test using the Arduino student kit
  2. Manually testing the system
  3. Building a pythonic adaptation layer using serial library
  4. Writing tests with Robot Framework against the firmware
  5. Analysing the pitfalls of implementation depending on firmware
  6. Creating a system that runs tests directly against the hardware
  7. Uploading a testing system to an external tester machine

Required Skills

  • Knowledge of or the will to learn tinkering with small electronics (resistors, conductors, individual components of a basic circuit)
  • Basic testing principles and terminology

Technical Setup

All attendees must provide their own laptop. The following software will need to be install

  • Python, at least version 3.12
  • Robot Framework, at least version 7.0
  • arduino-cli, at least version 1.5.1

Full setup instructions will be provide about two week prior to the workshop.

Arttu Taipale
Arttu Taipale
Arttu Taipale is an automation developer and a certified Robot Framework training provider, working at Knowit Solutions. His daily projects involve test automation and RPA across various systems. He is an open-source software enthusiast with a keen mind for problem solving. You can get his attention with a Robot Framework issue or a good sudoku.
franz haasfranz haas

Managing Concurrency / Parallelism with Robot Framework

🔗
Mar 09, 09:00 AM | 8 hrsfranz haas

With 22 years of experience in parallel systems, I’ll conduct a workshop on successfully dealing with concurrency in Robot Framework.

In this workshop, we will learn how to deal with concurrency in Robot Framework. We will create a blueprint for managing parallel systems in an enjoyable deterministic way.

Get ready for a more thready Python!

I have 22 years of experience in dealing with systems with inherent parallelism. From embedded systems with interrupt systems to distributed systems in the industrial context, NFC systems with multiple communication interfaces or measurement setups with many independent data sources.

In this workshop, I would like to share with you how it is possible to live with this problem and have a good experience while doing so.

Agenda

This workshop will be broken down into

  • We will explore the concept of parallelism/concurrency in the testing context and find common ground on naming
  • discuss why the class of solutions like Robot Framework struggles with threads
  • discuss the message based coordination of threads solution
  • In a hands-on session we will implement:
  • a keyword that enables threads to access Robot Framework logging infrastructure
  • two examples showcasing concurrency in Robot Framework, using select and threads
  • look at nondeterministic parallelism
  • what problems it brings
  • what advantages it brings
  • what alternatives we have

We will build up a mindmap for future decision-making and problem-solving during this process.

While the existence of the global interpreter lock has little influence on this topic, removing the global interpreter lock will bring attention to this topic, and dealing with parallelism will become more relevant once the Python world becomes more "thready".

Required Skills

I believe that if you care about concurrency/parallelism you would be a good fit. The challenges of concurrency and parallelism are largely independent of your Python and Robot Framework proficiency. Whether you're a beginner or an expert, you can benefit from this workshop.

Technical Setup

All attendees must provide their own laptop. We will run with a standard setup of Robot Framework, Python, and your editor of choice. No admin rights on the laptop are needed. Full setup instructions will be provide about two week prior to the workshop.

franz haas
franz haas
* 2024- present system engineering at renesas * 2013-2024 application engineering and validation/verification engineering at ams-osram * 2011 – 2013 home automation at intrate(c) * 2010 – 2011 RMA engineer at infineon * 2009 graduation at the university of applied sciences FH JOANEUM * 2007 – 2010 mixed signal ASIC development at FH JOANEUM * 2008 participation at the CERN Summer Student programe * 2001 – 2005 industrial automation at intrate(c)
Krzysztof ŻminkowskiKrzysztof Żminkowski
Agnieszka ŻminkowskaAgnieszka Żminkowska

Graph RAG for Robot Framework: Build an AI Assistant That Understands Your Project's Structure

🔗
Mar 09, 09:00 AM | 8 hrsKrzysztof ŻminkowskiAgnieszka Żminkowska

Vector search can tell you which keywords sound like "login". It can't tell you that changing one of them breaks 19 test cases across 6 suites. That takes a graph.

In this hands-on workshop you'll build a Graph RAG system that indexes a Robot Framework project — suites, tests, keywords, resources and libraries — and turns it into a queryable knowledge graph. Then you'll add semantic search and an LLM on top, so you can ask questions in plain English.

You'll leave with a working system, a template to point at your own project, and a clear picture of when a graph beats plain RAG.

Most Robot Framework projects outgrow the understanding of the people maintaining them. Keywords call keywords, resources import resources, and somewhere in there is a helper used by half your suites that nobody remembers writing. When you change it, you find out the hard way.

Plain RAG — the approach many of us started experimenting with over the past year — doesn't help here. It finds text that looks similar. It has no idea that one keyword depends on another. Graph RAG does, because it stores relationships as first-class data, not just similarity between chunks of text.

In this full-day, hands-on workshop, you'll build one from scratch.

What you'll build

A Graph RAG system that indexes a Robot Framework project and answers questions about it:

  • "What breaks if I change this keyword?" — trace every affected test across every suite
  • "What does this test actually do?" — follow the call chain down through nested keywords
  • "Show me everything related to authentication" — semantic search across keyword documentation
  • "Do we already have a keyword for this?" — find near-duplicates before writing another one
How the day runs

Morning — We start with why graphs, using a question vector search can't answer. You'll parse a realistic (deliberately messy) Robot Framework project into a knowledge graph of suites, tests, keywords, resources and libraries. By lunch you'll have a working impact-analysis tool — no AI required yet.
Afternoon — We enrich that same graph with embeddings and LLM-extracted concepts, then build a retrieval agent on top that combines semantic search with graph traversal. You'll finish by pointing the system at your own project.

Every section ends at a working checkpoint, so nobody gets stranded.

Who this is for

Robot Framework practitioners who can write Python and want to understand this technology properly rather than take somebody's word for it. No AI, machine learning, or graph database experience is assumed — we build up from first principles, and every concept is introduced through Robot Framework structures you already know.

What you'll take home

### Model a codebase as a graph
Design a graph schema for Robot Framework (suites, tests, keywords, resources, libraries) and write multi-hop queries tracing nested keyword calls.

### Parse a Robot Framework project programmatically
Extract elements from .robot, .resource, and Python files, handling edge cases like Suite Setup/Teardown, import chains, and embedded arguments.

### Build the retrieval layer
Generate local embeddings, map unstructured docs into the graph via LLM, and combine full-text, vector, and graph traversal into hybrid retrieval.

### Judge when this is the right tool
Identify where plain vector RAG falls short, when a graph is overkill, and how to estimate real infrastructure and LLM costs.

### Concrete artifacts you take home
* Working Graph RAG system built on a realistic Robot Framework project.
* Reusable template with an isolated parser adaptable to other frameworks.
* Checkpointed source code for every workshop stage.

### Immediate practical applications in your own projects
Safely refactor shared keywords, remove dead or duplicate keywords, trace unfamiliar call chains, and feed structural context to AI coding assistants.

Requirements

A laptop with Python and the ability to install packages.
You'll also need about $10 of credits with an LLM provider (instructions provided in advance). Actual workshop usage is roughly $1–2; the rest stays in your account for your own experiments afterword..

Krzysztof Żminkowski
Krzysztof Żminkowski
Senior software tester with over 15 yeas of experience. Working with RF since 2018. Exploring how AI will change the way we test software. Apart of that RF ambassador and member of the Wrobocon organization team, co-hots of Wrobocon.
Agnieszka Żminkowska
Agnieszka Żminkowska
My name is Agnieszka Żminkowska. I have been working in testing for over 10 years, with almost 8 of those years at Capgemini. I have worked on projects in the public administration and telecommunications sectors, mainly for clients from Germany. In my projects, I am responsible for test automation. I work as a Test Architect and Quality Manager.
Joonas KuismaJoonas Kuisma

Building Smarter Automation with Pabot: Mastering Parallel Execution in Robot Framework

🔗
Mar 09, 09:00 AM | 8 hrsJoonas Kuisma

Do your Robot Framework tests take too long to finish? Learn how to speed them up with Pabot! In this hands-on tutorial, you’ll discover how to use Pabot’s powerful parameters to control execution order, parallelism, and scheduling—so your test runs are faster and smarter. We’ll cover setup, configuration, and best practices for turning long test suites into efficient, scalable automation pipelines.

As your Robot Framework test suites grow, so does execution time. Slow feedback loops can hurt productivity and block continuous delivery. Pabot—an open-source parallel executor for Robot Framework—solves this problem by enabling safe, efficient parallel test execution.

In this interactive, hands-on workshop, we’ll dive deep into how to use Pabot effectively and intelligently.

What participants will learn:

  • How Pabot distributes and manages test execution across multiple processes.
  • How to control parallelism with --processes, --resourcefile, and other parameters to balance speed and stability.
  • How to define and influence test execution order using --ordering and suite-level configurations.
  • How to manage scheduling and dependency handling so that resource-intensive tests or shared environments are handled gracefully.
  • How to merge results and analyze parallel runs for consistent reporting.
  • How to integrate Pabot with Jenkins, GitHub Actions, and GitLab CI/CD.

We’ll also explore practical exercises demonstrating how changes in Pabot parameters affect runtime and execution behavior.

By the end of the workshop, attendees will be able to:

  • Configure and customize Pabot for projects of any scale.
  • Optimize test execution with fine-grained control over order, concurrency, and scheduling.
  • Avoid common pitfalls related to shared resources and data-driven tests.
  • Confidently integrate parallel execution into their automation pipelines.

Format:

  • Short introduction to Pabot internals and architecture
  • Guided setup and configuration demo
  • Hands-on exercises with provided test suites
  • Q&A and best practices discussion

This session suits Robot Framework users, test automation engineers, and CI/CD practitioners who want to take their automation to the next level by combining speed, reliability, and control.

Key takeaways:

  • Deep understanding of how Pabot manages parallelism.
  • Hands-on experience using key Pabot parameters (--processes, --ordering, --resourcefile, etc.).
  • Techniques for scheduling and balancing workloads in large-scale test suites.
  • Practical know-how to reduce runtime while keeping results stable and traceable.

Technical requirements:

  • Participants should come preinstall Python ≥3.9, Robot Framework, and Pabot.

All attendees must provide their own laptop. Full setup instructions will be provide about two week prior to the workshop.

Joonas Kuisma
Joonas Kuisma
Pabot maintainer and active Robot Framework community member. I focus on improving test scalability and execution speed through parallelization and open-source development.
Namik DelilovicNamik Delilovic

Bringing Robot Framework into n8n Visual Workflows: The Workshop

🔗
Mar 09, 09:00 AM | 8 hrsNamik Delilovic

Build your own automation workflows with Robot Framework and n8n in this hands-on workshop. Start with a fresh Linux server provided for you, set up n8n with Robot Framework support, and build three workflows: capture website data and screenshots, automate login and send Telegram notifications, then monitor listings and use AI to analyse new results. Based on the examples from RoboCon 2026, this workshop turns the demos into skills you can apply to your own projects. Basic Robot Framework knowledge is recommended; no n8n experience is required, and a laptop is all you need to bring.

Connect Robot Framework to other tools and services through n8n’s visual workflows. In this hands-on workshop, you will set up an environment on a fresh Linux server and build workflows that combine browser automation, messaging, and AI.

The workshop builds on the examples from my RoboCon 2026 talk, *Bringing Robot Framework into n8n Visual Workflows*. You will recreate those workflows, understand how they work, and explore how to adapt them to your own projects.

Set up your environment

You get your own fresh Linux cloud server for the day. On it, you will install Docker, run an n8n image with Robot Framework and the Browser library, and install the n8n-nodes-robotframework community node. You will learn how the components fit together and verify the setup with your first execution.

Build three practical workflows

  1. Capture website data and screenshots. Use Robot Framework’s Browser library to visit a website, extract its public IP address, and capture a screenshot. Inspect the execution output and download the Robot Framework log.
  1. Connect browser automation across nodes. Automate a login using input parameters, save browser state, and reuse it in a second Robot Framework node. Pass data between nodes, capture a screenshot, and send it to yourself through Telegram.
  1. Monitor listings and add AI analysis. Build a workflow that checks an online marketplace for new listings, tracks previously seen results, and processes new entries. Capture a listing and send the screenshot to an AI model for analysis. The results are delivered through Telegram and are also visible in the workflow output. A shared AI API key is provided. We will use this example to explore a pattern that can also apply to other monitoring tasks.

There will be time to experiment, ask questions, and troubleshoot together.

What you will take away

You will leave with example workflows you can adapt, plus practical experience connecting Robot Framework automation to other n8n nodes. You will know how to set up a server that runs Robot Framework and n8n, how to pass data and files between steps, and where AI analysis can contribute to a workflow.

Who should attend

This workshop is for anyone who wants to automate work across websites and tools, whether you automate every day or are just starting. Testers, RPA developers, and automation engineers will connect Robot Framework with other systems and can take each exercise further. But it is also for people outside engineering who want to see what automation can do for their work. Robot Framework basics are recommended.

What you need

  • A laptop. Everything runs on the provided server, so there is nothing to install.
  • Telegram on your phone. Exercises 2 and 3 send notifications through it. You can complete them without Telegram if you prefer.

The server and AI access are provided.

Namik Delilovic
Namik Delilovic
Namik Delilovic is a QA, test automation, and test management consultant and an active Robot Framework community contributor with 15 years of experience in software engineering. He is the creator of n8n-nodes-robotframework, the community node that brings Robot Framework into n8n workflows and is now part of MarketSquare, and he presented it at RoboCon 2026. He helps teams build stable end-to-end, UI, and API automation with Robot Framework, Playwright, and Selenium, integrated into CI/CD pipelines. He has led day-to-day QA in large enterprise programmes across media, energy, finance, telecommunications, and the public sector. His work also includes practical testing approaches for AI and chatbot features.
Yuri VerweijYuri Verweij
Tim de GrootTim de Groot

Beyond the Basics: Getting More out of Robot Framework

🔗
Mar 09, 09:00 AM | 8 hrsYuri VerweijTim de Groot

You know how to write Robot Framework tests and use libraries. What comes next?

In this workshop we will look at some of the less obvious ways to extend and influence Robot Framework: custom Python libraries, listeners, pre-run modifiers, data-driven approaches and the APIs behind them.

Once you know the basics of Robot Framework, there is quite a lot more you can do than just add more keywords and resource files.

In this workshop we will look at some of the extension points that are easy to miss, but become very useful when you want to change how Robot Framework behaves or build tooling around it.

We will create a small Python library and look at when that makes more sense than keeping everything in Robot Framework syntax.

From there we will look at listeners: how they can react to what happens during execution, what information they have access to, and what kinds of things they are useful for.

We will also look at pre-run modifiers and how they can change the test suite before execution starts. That can be useful for things like selecting, generating or modifying tests without changing the original suite files.

Along the way we will touch on the Robot Framework APIs behind these features and look at how they fit together.

We also want to cover a few related tools and approaches that are useful once projects get a bit more serious, such as "robot.toml", RobotCode and data-driven testing.

The idea is not to go through every advanced feature Robot Framework has. We want to show a few practical ways of extending it, explain when they are useful, and give participants enough understanding to start experimenting with them in their own projects.

We also want to leave some room for questions and problems from participants, so we can look at real examples together.

Who should attend
This is a hands-on workshop. Participants should already know the basic Robot Framework syntax and be comfortable with test cases, keywords, variables, libraries and resource files. Some Python familiarity is useful, especially for the custom library examples, but deep Python knowledge is not required.

Technical Requirements

Participants should bring a laptop with Python and Robot Framework installed. We will provide an example project to work with during the workshop.

Yuri Verweij
Yuri Verweij
Yuri Verweij is a Test Automation engineer from the Netherlands, 14 years in and still enjoying it. He co-maintains SeleniumLibrary, is a Robot Framework Ambassador, and helps run RoboCon and the Dutch RF community. When he's not reviewing pull requests he's usually carving a spoon, soldering something with an ESP32, or out in the woods looking at birds.
Tim de Groot
Tim de Groot
Test Automation Engineer

Conference Day 1 · 10 March

Times in Helsinki time

RoboCon
09:00
09:30
10:00
10:30
11:00
11:30
12:00
12:30
13:00
13:30
14:00
14:30
15:00
15:30
16:00
16:30
17:00
17:30
18:00
Breakfast
Break
Lunch
Coffee Break
Break
Linda van de Vooren
Linda van de Vooren

Known and unknown unknowns

🔗
09:10 AM–09:40 AM
By Linda van de Vooren

Unknown unknowns, the things we don’t know we don’t know, make learning hard and software testing tricky: finding no bugs could mean none exist, or that you’re looking the wrong way. In this talk, I share my history with this problem and my main remedy: ask lots of questions, about things everyone seems to know and about things you think you know. The audience takes part in a round of seemingly easy tasks that turn out not to work at all, and a few brave volunteers join me on stage. You’ll leave ready to challenge your assumptions and face unknown unknowns without fear.

When I'm learning something new I always struggle with my unknown unknowns: the things I don't know that I don't know. This is also a big topic in software testing. Because when you find no bugs, is it because they aren't there or is it because you don't know that you're looking at it the wrong way?

In this talk I will explain my troubled past with unknown unknowns, and how I deal with them. One spoiler: Ask a lot of questions. Questions about things everyone already seems to know. Also: ask things you already think you know.

You, the audience, also get to participate! We'll do a round of seemingly easy tasks to do together, where we'll find that it doesn't work at all! For a few brave souls I also have an assignment to do on the stage with me.

After the talk you'll be prepared to challenge things you think you know, and to face your unknown unknowns without fear.

Linda van de Vooren
Linda van de Vooren
In daily life I am an amateur (baritone!) saxophonist, and an experienced software tester. Living in the center of Netherlands, you can find me exploring nature, visiting at a concert or the theater. I enjoy working in complex environments, and do not shy away from a challenge, wether it be complexity through technical difficulties or because of a political environment. In any free time that is left, I am an avid gamer (Nintendo!) and enjoy reading (mostly fantasy, currently).
Gerwin Laagland
Gerwin Laagland

What Language Do Your Keywords Speak?

🔗
09:40 AM–10:10 AM
By Gerwin Laagland

A Robot Framework keyword can use familiar words and still mean different things to different people. Teams develop their own vocabulary and conventions: a project dialect. This talk looks at choosing domain or technical language, agreeing on what keywords do, and helping colleagues learn to use and write them. It offers questions you can use to review keyword names, arguments and behaviour with your team.

A Robot Framework keyword can use familiar words and still mean different things to different people. The team may rely on shared knowledge about when to use it and what it does.

Over time, teams develop their own vocabulary and conventions. These form a project dialect. Team members learn it from existing tests and tasks, keyword documentation, and each other. Familiar patterns help them write new keywords. They can also pass on inconsistencies that experienced colleagues have learned to work around.

This talk follows three questions:

Which language fits the work?
A test may describe approving an expense claim. The keywords underneath may click buttons or send HTTP requests. Both kinds of language have a place. We will consider where each belongs and which details someone needs to understand or use a keyword.

What do we mean by this keyword?
Names, arguments and behaviour affect how people understand a keyword. Using one keyword can shape what they expect from another. We will look at how established terms and conventions help, and when differences between related keywords are useful or confusing.

How do colleagues learn to use and write these keywords?
Colleagues often use existing keywords as examples. Pairing and review can explain the choices behind their names, arguments and behaviour. We will discuss how this helps people understand which conventions apply when writing a new keyword.

You can use these questions in your next keyword review:
- What do you need to express in this test, task or keyword?
- What must you know before using the keyword, and what can you expect it to do?
- How will a colleague learn to use it and write related keywords?

Gerwin Laagland
Gerwin Laagland
Gerwin Laagland is a test engineer and board member of the Robot Framework Foundation. His work focuses on back-end systems and integrations, using Robot Framework to build and maintain test automation. Alongside project work, Gerwin teaches Robot Framework courses and leads community workgroups on documentation, the Robot Framework Certified Professional (RFCP) syllabus and training accreditation. He enjoys helping colleagues understand the automation they work with and sharing what he learns through teaching and community discussions.
José María Martín Blázquez
José María Martín Blázquez

The Robot Framework You Don’t See: Why GMV Joined the Foundation

🔗
10:55 AM–11:25 AM
By José María Martín Blázquez

Why would a large engineering company pay to support a tool it can use for free? After presenting at RoboCon 2026, GMV decided to join the Robot Framework Foundation. This talk tells that story through real projects where Robot Framework helps validate systems behind services millions of people rely on—from satellite navigation to other critical infrastructure. We will show how business-critical use turned open-source consumption into responsibility, and why more companies should consider taking the same step.

Robot Framework is free to use, but it is not free to sustain.
Like many organizations, GMV started as a user of Robot Framework. Over time, however, the framework became part of the testing strategy of increasingly demanding projects. At RoboCon 2026, we shared some of that experience with the community.
That participation triggered a broader reflection inside the company: if an open-source project is providing real value to systems we build and validate, should we remain only users of it?
A few months later, GMV joined the Robot Framework Foundation.
In this talk, I will tell the story behind that decision through a set of real use cases. Instead of presenting Robot Framework features, we will look at the systems behind the tests: projects and services that people outside the testing community can recognise and, in some cases, use in their everyday lives.
These examples reveal something that is easy to overlook: Robot Framework may be invisible to the end user, but the software it helps us validate is not.
From there, we will look at the reasons that led GMV to move from using Robot Framework to supporting its ecosystem: sustainability, knowledge sharing, community involvement and the strategic importance of reliable open-source tooling.

José María Martín Blázquez
José María Martín Blázquez
I studied at the Complutense University of Madrid obtaining a degree in Computer Engineering. In 2008 he enjoyed a grant at “GMV Soluciones Globales e Internet” in the Galileo SPF project. In 2009, after finishing my studies, I joined GMV Aerospace and Defense S.A and since then I've been working on a large number of projects as a SW developer and Software and Systems Validation engineer, all of them related to Ground Segment activities. I'm enthusiastic of testing, automation and recently AI applications.
Raphael Nömmer
Raphael Nömmer

Closing the loop: Using Test Gap Analysis and Coding Agents to ship with confidence

🔗
11:25 AM–11:50 AM
By Raphael Nömmer

Coding agents increase the speed and in many cases scope of code changes, but leave us with quality debt and blind spots in our testing. As LLMs churn out code and tests faster than anyone can review them, we lose oversight and more critical changes slip through untested.
I'll show how Test Gap Analysis closes the loop, turning into a safety net for agentic coding: feed gap data back to your agents which can address them automatically, for example via RobotMCP, making sure your agent closes coverage holes in your code instead of generating arbitrary tests.
Join me to ship fast with confidence.

Coding agents have made writing code and tests dramatically faster. As agents churn out changes and whole test suites faster than any team can review them, our already limited picture of the codebase gets even blurrier. We lose track of what parts of last week's work are actually exercised by tests and which only look like they are. That is quality debt, and it accumulates.

More generated tests and raw coverage percentages don't help much here. A suite can sit at a comfortable 80% test coverage while many lines an agent edits during a sprint go untested, because an aggregate number says nothing about code that was modified. Test Gap Analysis approaches the problem from the other side: it cross-references what changed in your code with what your tests actually executed, and surfaces the intersection of new or modified code that no test has ever run. Instead of a number you get a map of concrete risk.

In the talk, I will go through some of the observed effects AI agents have on software testing and product quality. I will show how test gaps can help by becoming a feedback loop for agentic coding. Once they are available as structured, real-time data, they can become a signal your agents can act on.

I'll walk you through an example setup: capturing coverage from your Robot Framework test runs, computing gaps against the diff, and exposing test gaps to a coding agent to implement additional tests via, for example, (Robot)MCP. This allows the agent to write tests for the specific untested changes it introduced, instead of just generating plausible-looking tests and hoping they matter.

We will also look at the limits. With Test Gap Analysis we can see which changed code was executed, not whether the code is bug free. It puts the focus on where we are missing coverage as tests cannot find bugs in code they never execute. It needs coverage from real test runs, so coverage instrumentation is an essential part of the setup. And an agent that closes gaps will cheerfully write tests that satisfy the metric without deepening anyone's understanding, so human review still matters.

Raphael Nömmer
Raphael Nömmer
Raphael Nömmer is a Software Engineer and Software Quality Consultant at CQSE. He holds a Master’s degree in Computer Science from the Technical University of Munich (TUM) and is currently pursuing his PhD, focusing his research on software test optimization. At CQSE, his work is focused on helping companies with improving their testing processes and setups.
Alesya Shapira
Alesya Shapira

Modular Test Automation at Scale: Building Robot Framework with Lego Blocks

🔗
12:15 PM–12:45 PM
By Alesya Shapira

Managing test automation across multiple teams and products in a large organization gets messy fast. In ABB Drives, we went modular: shared Robot Framework keywords in installable Python packages, and each test repo picks only what it needs - like Lego blocks.

In ABB Drives, we use Robot Framework to test embedded products across many disciplines: HW verification, firmware testing, low-level platform tests, and more. Different teams, different setups, different needs.

Our first Robot Framework proof of concept was a single monorepo. That didn't scale. So we split into multiple test repositories, one per testing domain, and shared the common Robot keywords as Python packages installable with PIP. Each repo takes only what it needs. The result is something we like to call modular test automation - you build your test repo from provided Robot Framework building blocks, like Lego.

To keep all the library packages consistent and up to date, we created a Robot Library Template. It defines the directory structure, static analysis tools, pipelines, and documentation. It lets us spin up a new library package quickly and, just as importantly, propagate improvements back to existing packages when the template evolves.

Each library is extensively tested: unit tests and Robot Framework tests cover the library itself. We also run integration tests against our largest test repository to catch regressions before a new version ships.

We've now built the same kind of template for test repositories and it's being rolled out across the organisation. The goal is to help teams set up new repos fast while enforcing baseline quality rules (like Robocop linting and formatting).

This talk is for anyone scaling test automation or maintaining multiple related packages, from large organizations to solo developers and small teams. The architecture is straightforward, but the tradeoffs become visible only after you've experienced the alternative. We'll share what worked for us, what didn't, and the practical lessons we learned along the way.

Alesya Shapira
Alesya Shapira
Test Architect at ABB Drives
Florian Wellens
Florian Wellens

KaaS 🧀: Keyword as a Service – Bridging Domain Knowledge and Code

🔗
12:45 PM–01:15 PM
By Florian Wellens

In complex, hardware-heavy, and domain-rich environments, test automation faces a classic dilemma: Developers know how to write clean code, but lack deep understanding of real-world edge cases and field behavior. On the other side, veteran QA engineers hold decades of invaluable domain and system knowledge, but do not write Python code or manage complex software frameworks.

This talk tells the story of KaaS 🧀(Keyword as a Service) — an architectural evolution aimed at bridging this knowledge gap without forcing QA experts to become software developers.

_The Story behind Kaas:_
It all started with a simple ambition: we wanted to move beyond basic integration tests and unlock the full potential of end-to-end (E2E) automation. Robot Framework seemed like the perfect orchestrator—a powerful tool capable of interacting with all our systems, hardware, and APIs, backed by a vast ecosystem of ready-to-use libraries.

Equipped with the right libraries, we defined our first concepts, automated our initial test cases, and hit the ground running. Very quickly, we realized that certain scenarios were being used repeatedly. Naturally, we started writing our own custom keywords using .resource files. At first, it felt like a massive triumph: the early E2E tests passed, the concept was proven, and enthusiasm spread across the company.

More and more colleagues jumped on board, writing keywords and expanding test suites. But without a unified architectural vision, momentum turned into madness. Instead of reusing existing building blocks, engineers began copying keywords, reimplementing them under slightly different names, and throwing everything into a single, chaotic repository. The climax of this wild era was the creation of a monolithic "Master Resource File" that got imported into every single test suite.

As team involvement grew, so did the chaos—until the inevitable day of reckoning arrived. Our test suites became flaky, untraceable, and utterly unmaintainable.

In short: it was absolute Cheese!

Standing in the rubble of our test framework, we had to ask ourselves some hard questions: How do we structure this chaos? How do we enforce clear ownership? How can we make keywords truly reusable across multiple products and teams without endless duplication?
And how on earth do we explain to veteran QA testers that—even though both are written in the exact same Robot Framework syntax—they are free to author Robot test suite files, but shouldn't touch the underlying resource files?

The answer lay in rethinking our entire approach: Custom Robot Framework Libraries built as versioned Python packages.

And that’s how KaaS (Keyword as a Service) was born.

We shifted to a product mindset: developers build product-specific Python packages for QA, testers, and project teams. KaaS introduced clear ownership, scheduled release cycles, and keywords named so intuitively that anyone testing our products could instantly use them. But the journey didn't end there. We had to embrace steep learning curves, massive refactoring efforts, and the ongoing challenge of achieving true cross-product unification.

Florian Wellens
Florian Wellens
Florian Wellens is a Product Owner for Build & Test Infrastructure at Scheidt & Bachmann Fare Collection Systems GmbH. He leads the development of the platforms that enable fast, reliable software delivery, with a focus on CI/CD pipelines, scalable build and test environments, and test automation. His work helps development teams ship changes with confidence and shorten feedback cycles from commit to release.
Many Kasiriha
Many Kasiriha

Let It Go — A Critical Look at rf-mcp, RobotCode and Agent Skills

🔗
02:45 PM–03:15 PM
By Many Kasiriha

For a year, the Robot Framework MCP server was my answer to AI-driven test automation: stepwise execution, live feedback, from prompt to runnable test. Agent Skills seemed limited by comparison. Then, while preparing a workshop on agentic engineering, I took a closer look at the RobotCode CLI. Beyond robot.toml profiles, structured results and library docs, I found robot-debug and the REPL, both increasingly built for AI agents. Can an agent work with Robot Framework effectively through RobotCode alone? What's still missing? And is it time to let go of rf-mcp?

In this talk I put RobotCode, Agent Skills and Hooks against my own MCP server. I'll run the same tasks in each setup and compare the results. Then we'll look at what MCP still does best, what's still missing and what the future of AI engineering with Robot Framework could look like. And I'll answer the question every maintainer eventually has to face: is it time to let go?

Many Kasiriha
Many Kasiriha
Lead Technology Architect at DSV with a focus on QA and AI engineering, father, husband and dog owner, musician, likes farming games but is bad at gardening
Ru Cindrea
Ru Cindrea

Generating Robot Framework Game Tests with AI, Out of the Box

🔗
03:15 PM–03:45 PM
By Ru Cindrea

What if your AI assistant could explore a running game and hand you a clean, runnable Robot Framework suite — no boilerplate, no hand-written locators? This talk shows exactly that. Using AltTester®'s CLI and MCP server, an AI assistant connects to a live Unity game, explores it, and generates Robot Framework tests organised into readable actions, checks, and flows. I'll walk through a real co-op cooking game from first connection to an all-green run, and show why Robot's keyword-driven syntax is a natural fit for AI-generated tests.

Writing the first tests for a new application is mostly mechanical work: discovering locators, scaffolding a project, structuring a suite, wiring up setup and teardown. It's exactly the kind of work that's tedious for a human and well-suited to an AI assistant — if the output is something you'd actually want to maintain.

This talk shows how to get runnable Robot Framework tests out of the box by letting an AI assistant explore a live game and generate the suite for you. The reason Robot Framework works so well here is the same reason we like it generally: its keyword-driven syntax reads close to natural language, so the generated tests stay legible and easy to extend by hand instead of turning into opaque code you're afraid to touch.

I'll use a real example — a co-op cooking game built in Unity and instrumented with AltTester® — and walk through the whole path:

  • How the AltTester® CLI and MCP server give an AI assistant a scriptable way into a running game: finding objects, simulating inputs, reading and writing state
  • How an installed Robot skill guides the assistant to plan, generate, run, and record tests in Robot Framework specifically
  • What the assistant produces: a suite organised into a clean three-layer structure — actions (low-level interactions), checks (assertions), and flows (multi-step scenarios) — that reads almost like the test cases themselves
  • Where the human stays in charge: reviewing the plan, deciding what's worth testing, and approving before code is generated
  • Running the result with alttester run-tests and watching it execute live in the game, ending with a green dashboard report

The bigger point is high-level and applies well beyond games: AI is good at the laborious scaffolding, and Robot Framework is a great target for that generated output because it stays readable. The judgement about what to test and what correct means stays with you.

Audience takeaway: a concrete sense of how AI-assisted test generation can produce maintainable Robot Framework suites, and why Robot's design makes it an especially good fit. This is a fast-moving space — I'll focus on the durable ideas rather than any single tool version.

Who it's for: Robot Framework users, QA engineers, and SDETs curious about AI-assisted authoring. No game-testing background required.

Ru Cindrea
Ru Cindrea
Ru Cindrea is a senior test consultant and managing partner at Altom, living in Helsinki, Finland. With over 20 years of experience, she believes all testing is exploratory and applies this mindset to complex testing challenges and when building test automation frameworks. Her focus has mostly been on testing mobile applications and embedded systems, as well as on automating game testing, where she is one of the main developers of the AltTester® tool. She has been a BBST® instructor for over 10 years and she has been working on developing the BBST® materials and practical assignments that draw from her past project experiences.
Ruben van Kruistum
Ruben van Kruistum

Too big to migrate: moving EDSN from SeleniumLibrary to Browser Library in weeks

🔗
04:15 PM–04:45 PM
By Ruben van Kruistum

EDSN's Robot Framework suite, with more than 320 test cases and 10,000 lines of code, couldn't be moved to Browser Library step by step, and a months-long rewrite would have chased a moving main branch. It was written off as too big to estimate. We migrated it in a few weeks with an LLM-assisted pipeline built around Robot Framework's own parser and Robocop. This talk shows how we did it: how to assess whether your own suite is ready, which SeleniumLibrary patterns resist mechanical translation, and how we kept an LLM on a short leash inside our workflow.

Many teams have the ambition to migrate from SeleniumLibrary to Browser Library and keep postponing it. At EDSN the blocker was structural. Test cases called keywords that called shared low-level library code, so there was no way to migrate part of the suite at a time. A big-bang rewrite would take months, and every month would bring new changes on main to catch up with. Like a rocket that needs more fuel to carry its fuel, the migration grew with its own duration. Shortening that duration broke the loop.

### The approach:
- Parse the suite with Robot Framework's own model, and translate the mechanical bulk deterministically.
- Give the LLM only bounded tasks, for instance:
* Rewriting wait semantics
* Resolving composed locators
* Untangling custom keywords
- Verify every step with Robocop (linting and formatting), dry-runs and real execution.
- Have a human review what's left.

The same shared keyword layer that blocked a step-by-step migration also made it easy to absorb new changes along the way: they landed at test-case level, on top of the already-migrated keywords.

### Talk structure (20 minutes):
1. The problem, and why it looked impossible
2. How to assess whether your own suite is migratable
3. The pipeline: what's deterministic and where the LLM sits
4. The messy parts: what it got wrong and where the human hours went
5. Takeaways, what's next for migrations into RF, and why good keyword layering pays off

Attendees will be able to judge how ready their own suite is for migration, get a look at tooling we're working to open-source for the Robot Framework community, and hear how we're extending the same approach to bring suites from other tools into Robot Framework.

Ruben van Kruistum
Ruben van Kruistum
Ruben van Kruistum is a test automation and DevOps engineer with over ten years of experience, and technical lead for AI migration tooling at QA Company. He has built test frameworks and CI/CD platforms for major Dutch organisations in energy, aviation and infrastructure. He now focuses on applying AI to test automation without losing quality or control. He's also a classically trained cellist, and does regular Twitch streams making electronic music.
Simon Meggle
Simon Meggle

Don't Let the Robot Guess: Selector Strategies Unveiled

🔗
04:45 PM–05:15 PM
By Simon Meggle

AI can write selectors, but it can’t tell you whether to trust them.

This talk shows how SeleniumLibrary and Browser Library interpret locators for web testing, where they differ, and what makes a selector robust.

With or without AI, understanding selectors remains a core skill for every test automation engineer!

Getting a selector that works today is easy.
Getting one that survives the next UI change is not.

We’ll cover:

  • The locator strategies of both libraries (Browser/Selenium) and how each one interprets what you write
  • Key differences between the two and the pitfalls they create
  • What makes a selector robust and what makes it fragile

AI is a great assistant, but you’re still the one who has to review its work.
This talk gives you the foundation to do that with confidence.

For: Robot Framework users working with either library. Basic knowledge is enough.

Simon Meggle
Simon Meggle
tbd
Sander van Beek
Sander van Beek

Months until 💩

🔗
05:35 PM–06:05 PM
By Sander van Beek

If you leave your team today, how long until your test code turns to 💩?

I like switching teams/organizations every 1-1.5 years. I'm more of a builder than a maintainer, so regularly switching keeps things interesting to me. But I don’t want everything I’ve built to fall apart the moment I walk out the door. In my most recent switch, I found myself using the surprisingly useful metric: If I leave today, how long until things turn to 💩?

How long until test automation breaks down? Until team dynamics unravel? How long until that change I championed is forgotten? How long is long enough for me to leave without worrying?

In this talk, I’ll introduce this metric and talk about some practical ways you can extend the time-to-first-💩 and time-to-total-💩. How can you build automation, processes, and team culture that last after you're gone?

Sander van Beek
Sander van Beek
I'm a technical tester that focuses on automation. To me, a test that's worth doing is also worth automating. I combine my technical expertise with the human and organizational sides of testing. Technical solutions are great, but the bigger challenge is making people use them at scale. I think it's fun to create something new. I think complexity is fun and more complexity is more fun. I use my programming skills to tame complexity.

Conference Day 2 · 11 March

Times in Helsinki time

RoboCon
09:00
09:30
10:00
10:30
11:00
11:30
12:00
12:30
13:00
13:30
14:00
14:30
15:00
15:30
16:00
16:30
17:00
Breakfast
Break
Lunch Break
Coffee break
Pekka Klärck
Pekka Klärck

What’s New in Robot Framework

🔗
09:00 AM–09:30 AM
By Pekka Klärck

What has happened in Robot Framework since the last RoboCon, and what is coming next? Robot Framework creator Pekka Klärck presents the latest developments in Robot Framework core and the growing ecosystem around it.

In this traditional RoboCon talk, Pekka Klärck, the creator and lead developer of Robot Framework, presents what has happened in Robot Framework since the last RoboCon.

The talk covers the most important new features in recent Robot Framework releases, with practical examples, and the progress of the new Robot Framework User Manual. Pekka also gives an overview of the wider ecosystem: new libraries and tools created by the community over the past year.

Whether you use Robot Framework every day or follow it from a distance, this talk gives you a quick update on where the framework is today and where it is heading.

Key takeaways

  • Know the most important new features in recent Robot Framework releases
  • Learn about the new Robot Framework User Manual
  • Discover new libraries and tools in the Robot Framework ecosystem
  • Get an idea of where Robot Framework development is heading
Pekka Klärck
Pekka Klärck
Pekka Klärck is the inventor and lead developer of Robot Framework. He started the project in 2005 as part of his master’s thesis at Helsinki University of Technology (now Aalto University) and has been steering its development ever since. Pekka is known not only for his technical expertise but also for his dedication to fostering an open-source community. He actively collaborates with contributors worldwide and regularly shares his insights at conferences and events.
Yuri Verweij
Yuri Verweij
Tim de Groot
Tim de Groot

Waiter! There's AI in my open source!

🔗
09:30 AM–10:00 AM
By Yuri Verweij, Tim de Groot

AI is already in your project, whether you invited it or not. As a contributor I've used AI to help write code, and I've received contributions where AI clearly wrote most of it, up to fully AI-generated PRs. This talk is a lighthearted, honest look at what's actually worked, what's gone wrong, and how to handle AI-assisted contributions without losing your mind or your project's quality. No hype, no doom. Just field notes from maintaining open source in the age of the helpful robot.

We don't get to decide whether AI shows up in open source anymore. It's in the code we write, the issues people file, and increasingly in the pull requests that land in our queue. Some of it is genuinely helpful. Some of it is a confidently wrong wall of code from a contributor who can't explain a single line of it.
This talk shares my own experience from both sides of that line. As a contributor I use AI tools in my own workflow for designs, explanations, reviews, and the boring parts. I've also been on the receiving end of contributions where AI did most of the work, including PRs that were essentially generated start to finish.
I'll cover what has actually been useful, where AI helps a maintainer rather than just adding noise, and the failure modes worth watching for: plausible-looking code that doesn't fit the project, tests that assert nothing, and contributors who can't engage with review feedback because they didn't write what they submitted.
Then the practical part: how to handle AI-assisted and fully AI-generated contributions in a way that's fair to contributors, honest about quality, and sustainable for maintainers. What to ask for, what to push back on, and how to set expectations without slamming the door on people who are learning.
This is a sharing-of-experience talk, not a lecture. Expect concrete examples, a few war stories, and some opinions you're free to disagree with. You'll leave with a clearer sense of how to keep your project's quality bar while AI keeps showing up to help whether you asked it to or not.

Yuri Verweij
Yuri Verweij
Yuri Verweij is a Test Automation engineer from the Netherlands, 14 years in and still enjoying it. He co-maintains SeleniumLibrary, is a Robot Framework Ambassador, and helps run RoboCon and the Dutch RF community. When he's not reviewing pull requests he's usually carving a spoon, soldering something with an ESP32, or out in the woods looking at birds.
Tim de Groot
Tim de Groot
Test Automation Engineer

Lightning Talks

🔗
10:45 AM–11:45 AM

Lightning Talks are short (max 10 min.), engaging presentations where anyone from the Robot Framework community can share ideas, experiences, projects, or lessons learned.

Have something to share? Submit your proposal! All proposals will be available for the community to read and explore. At the end of Day 1, we'll come together with all participants to select the five to six talks that will take the stage.

By the community, for the community!

Monica Oyugi
Monica Oyugi

We Stopped Rerunning Our Flaky Tests

🔗
12:05 PM–12:35 PM
By Monica Oyugi

Every team has tests that fail on Tuesday and pass on Wednesday, and most of us deal with them the same way: rerun and hope. This talk is about what happened when we stopped. Drawing on years as both a developer and a QA engineer, I'll walk through how we tracked down the flaky tests in our Robot Framework suite, what the causes really were (some boring, some not), and the habits that kept the suite trustworthy. You'll leave with a practical way to find and triage flakiness in your own suite.

I spent four years as a software engineer before moving into QA, where I've worked for six years as a senior QA engineer. Having sat on both sides, I've noticed that flaky tests tend to fall into a gap. Developers see them as a testing problem. Testers see them as noise. So the test gets rerun until it goes green, and nobody looks closer.

At some point, that stops being a small annoyance. People stop looking at red builds, real bugs slip through, and the suite quietly loses everyone's trust.

This talk is the story of how we dealt with it. It's not a list of best practices from a book. It's what we actually did, in the order we did it, including what didn't work.

How we measured the problem. Before fixing anything, we needed to know which tests were flaky and how often. Instead of looking at one build at a time, we collected results across many runs and looked for tests that changed outcome without any code change. Our gut feeling about "the flaky ones" was partly wrong, and the data showed it.

What the causes really were. Most of them were the usual suspects: fixed waits that were too short on a busy CI machine, tests that depended on each other or on leftover data, and unstable test environments or third-party services. But a few were different. Some tests we had written off as flaky were correctly catching real intermittent bugs in the application, like race conditions. My time as a developer helped me spot those. I'll show real before-and-after examples of each type.

What we tried that didn't help. Automatic retries and bigger timeouts. They made the numbers look better while making the problem harder to see and easier to ignore. I'll explain why.

What we changed in how the team works, so flakiness doesn't creep back: a quarantine for unstable tests with a named owner and a deadline, a rule that new tests must pass repeatedly before joining the main suite, and a flakiness report everyone on the team can see.

Who this is for: anyone who maintains an automated suite, whether you write the tests, run them, or are tired of explaining red builds. The examples are in Robot Framework, but the thinking applies elsewhere. No advanced knowledge needed.

What you'll take away: a simple way to find out how flaky your suite really is, a short list of the usual suspects to check first, and a solid argument for fixing flakiness at work instead of hiding it.

Monica Oyugi
Monica Oyugi
I'm a Senior Quality Assurance Engineer driven by the intersection of technology and social impact. My work extends beyond code quality to building inclusive communities that elevate underrepresented voices in tech. Through speaking engagements, mentoring, and event support, I actively champion diversity and innovation across platforms like Women Techmakers, PyCon, and DjangoCon. As a volunteer co-chair for DjangoCon US and Lead for PyCon Kenya, Part of API Festival Kenya, and DroidCon Kenya, I cultivate spaces where collaboration thrives, and knowledge flows freely throughout both the global and East African tech ecosystems. My commitment to fostering safe, inclusive environments led me to join the Python Software Foundation's Code of Conduct team, where I help ensure our community remains welcoming and accessible to all. I leverage my technical expertise and community leadership experience to inspire the next generation of technologists, particularly those from underrepresented backgrounds, empowering them to unlock their potential and shape the future of our industry.
Tatu Aalto
Tatu Aalto

CI already knows why your test fails

🔗
12:35 PM–01:05 PM
By Tatu Aalto

Flaky tests are inevitable, everyone has them. Test maintenance is exhausting work and a blind spot in most testing talks. I spent years chasing a mysterious flaky tests in the Browser library, then realized: How I could make LLM read our logs and could it find something that humans could not. This talk is about that discovery, what I learned about AI cognition vs. human cognition, and when AI is actually useful for test maintenance. Spoiler: it's not complexity—it's having the right data.

# My Story: From Over-Engineering to Simple Solutions
Flaky tests are the almost the only certainty in testing. You've probably looked at a failing test, felt the burden of reading thousands of logs lines, and moved on. I know I have. And so have other QA engineers that I have talked to.

At least three years, there had been a bug hiding in Browser library as random failures in the CI workflow. None of the maintainers could find the reason behind the random failure, but AI, with the right data in the context, could easily find the bug in the Browser library code base.

What You Will Learn

### The journey
Why I initially over-engineered this problem with an agentic LLM workflow in robotframework-analysis project. It burned tokens and was over complicated to the problem at hand. But that failure made me realize: Browser library data isn't scattered across different systems. It's in two places: the repo and GitHub artifacts.

### The shift
How I switched to a simpler approach:
- Scripts to consolidate CI logs and artifacts from GitHub
- Post process the data, to match my local enviroment: Path names, libary locations and so on
- A local database to correlate test runs and failures
- A simple interfaces for humans and LLMs alike
- A single LLM model investigating locally with full context

### The proof
The highlight-caching bug, that hidden for years in the Browser library. Why we humans gave up (we fatigue reading lots of log lines of interleaved logs from multiple pabot processes). How the LLM found it: getting initial hint from the db data -> downloading full test results GitHub Artifacts -> investigating more deeply -> playwright-log.txt + test logs in one context window. Then seeing the cascade: Test A started → Test B cleared cache → Test A failed.

### The real insight
This isn't just only about LLMs never getting bored. It's about cognitive fit. Some problems need one mind holding multiple threads in context at once and sometimes spotting the right threads is hard. That's where LLMs can excel and where humans might struggle.

Tatu Aalto
Tatu Aalto
Tatu Aalto has been doing testing for +25 years and have been part of the Robot Framework ecosystem for +15 years. He maintains several projects in Robot Framework world, mainly focusing on UI automation and library development. He is currently the lead developer of Browser library and SchemathesisLibrary. He currently works at OP where he builds testing capabilities as service and is one of the AI evangelist in the company.
Marc
Marc
Chris Zöller
Chris Zöller

Robot Framework in Air Traffic Control: From Requirements to Regulatory Approval

🔗
02:35 PM–03:05 PM
By Marc, Chris Zöller

At DFS, Germany's Air Navigation Service Provider, Robot Framework is a central part of a fully integrated testing and compliance ecosystem for modern cloud-based Air Traffic Control systems.

In this talk, we show how we combine Robot Framework, PlatynUI, JSON Remote RPC, DIM RM, and our in-house synchronization toolchain to achieve end-to-end traceability from requirements to automated test results. Attendees will learn how keyword-driven testing, CI/CD pipelines, and regulatory evidence generation work together in a highly regulated environment governed by standards such as ED-153.

Modern Air Traffic Control systems must satisfy two very different worlds:

fast, cloud-native software delivery
strict regulatory approval requirements

At DFS, the German Air Navigation Service Provider, we use Robot Framework as a core part of our software verification strategy for business-critical ATM systems.

This presentation shows how we built an integrated testing ecosystem around Robot Framework to support both efficient software development and regulatory compliance.

Topics covered include:

Keyword-Driven Testing with Robot Framework in ATM software projects

Automated testing of cloud-based HMI frontends using PlatynUI
Backend Service and API testing using JSON Remote RPC
Building and maintaining a multi-layer keyword architecture
Cross-project reuse of automation assets through a Common Keyword Library (CKL)
Synchronization between Robot Framework and Dimensions RM
End-to-end traceability from requirements to test execution results

Attendees will gain practical insights into how Robot Framework can be extended beyond pure test automation and become a central building block of a compliance-oriented software engineering process.

Marc
Marc
later - > 20 years into testing and qa
Chris Zöller
Chris Zöller
Asko Soukka
Asko Soukka
laelhaar
laelhaar

Robot Framework and BPMN: One Tool for Automation and Testing

🔗
03:05 PM–03:35 PM
By Asko Soukka, laelhaar

Robot Framework is not just a test automation tool. The same libraries and keywords used to verify systems can also be used to automate work. Business tasks rarely stand alone, but are part of larger workflows involving multiple steps, systems, and decisions. BPMN (Business Process Model and Notation) is the global standard for modeling and documenting those workflows. And also those workflows are code and must be tested. Our talk presents Robot Framework both as a task automation solution, and the solution to test the processes orchestrating those automations.

This talk presents robotframework-operaton, an open-source, Robot Framework-based tool with a keyword library for acceptance-testing BPMN processes with Operaton: a community-driven, free and open-source BPMN engine. The tool runs an in-memory Operaton process engine behind ordinary .robot tests. By default, a test project needs only the library JAR, Robot Framework files, and the BPMN or other resources being tested. There is no separately deployed process engine or test environment to maintain.
The tool and library are being developed to make it easier to write tests for real administrative business processes. Operaton provides assertion libraries for Java unit tests, but those tests are primarily aimed at developers and require knowledge of the engine's Java APIs. They are not an accessible way to describe and verify process behavior for the wider group of people who understand the business process. Just as BPMN helps bridge the gap between IT and business when understanding an implemented process, Robot Framework can bridge that gap when testing it: the process can be exercised and verified with readable keywords instead of implementation-specific Java code.
The technical solution packages the Operaton engine and the Robot Framework integration into a single self-contained JAR. Test suites can deploy their BPMN resources and control an isolated in-memory engine through keywords, without importing Java APIs into the test or maintaining a separate test service. We will show how the keyword layer maps Robot arguments to engine operations, tracks the active process instance, manages engine setup and teardown, and exposes useful assertions without leaking engine-specific plumbing into every test.
The keyword library can also visualize BPMN execution and generate both tabular and visual test-coverage information directly in Robot Framework logs. That includes a list of BPMN elements that remain uncovered, making process-test results easier to inspect and improve.
Executing test suites only requires the self-contained JAR, Robot Framework files, and the tested BPMN resources. However, for authoring, JVM startup time is an issue, and RobotCode's language server needs a library it can inspect to provide keyword names, arguments, and documentation. To address these needs, the tool provides a Python proxy library and uses Robot Framework's familiar XML-RPC remote library interface to connect to a persistent JVM process running the library. To make this setup feasible, we conclude with a custom VS Code extension that helps set up all the dependencies needed for a successful authoring experience.

Asko Soukka
Asko Soukka
Asko has spent his entire professional career in open-source software development and prefers open-source solutions whenever possible. With over 25 years of experience in Python development, he has worked on a wide range of projects, from microservices to highly customized Plone CMS deployments, as well as testing and automation using the Robot Framework. Since 2020, Asko has focused on building solutions around BPMN-based automation and orchestration. He is currently working as a software architect at the University of Jyväskylä.
laelhaar
laelhaar
Computer science masters student
Arttu Taipale
Arttu Taipale

RF Software Supply Chain Security - what's at risk?

🔗
04:05 PM–04:35 PM
By Arttu Taipale

You cannot know every line of code you utilize in a project - in fact, you may likely ever see just a tiny fraction of it. The rest of it lies in the software supply chain, and you must be able to know who you can trust, and what risks you are dealing with when using software delivered by others. With high-risk and widely affecting vulnerabilities such as the xzutils backdoor becoming reality in the world of software, it's a good moment to consider where the risks lie with Robot Framework. How prepared are you as a developer to assess the risks in your software supply chain?

Let's automate our tests! You only need Robot Framework. And a couple of libraries. Robot Framework needs Python. You need an operating system to operate your development environment, and the operating system will use a kernel to communicate with the hardware you use. The hardware in your computer is supplied from multiple providers across the globe. In addition you may use Slack to communicate with your team, Teams as the meeting software to attend stand up calls, and git as the version control tool. Your favorite cloud provider is providing you with a testing environment and services for the application - or perhaps you have your own server room, with hardware from yet another dozen companies from another continent, using Kubernetes and other software to organize the application software.

The software development world is a web of dependencies and supply chains that is almost incomprehensible to the normal user. To write a single Robot Framework web application test, you are using code written by probably thousands of software engineers. A single liability in this supply chain could mean the loss of confidence in your product. If unnoticed and without mitigating outcomes or managing risks, empires can be brought down to their knees.

When dealing with security, it's always a people business. In this talk, we take a look at the people and organizations in control of the software you use to get those tests in your dashboard from zero to red to green. We learn together about the supply chain for software, awareness of risks and how to mitigate them. We will also discuss how the landscape is evolving, and what's at the forefront of software security for us.

Arttu Taipale
Arttu Taipale
Arttu Taipale is an automation developer and a certified Robot Framework training provider, working at Knowit Solutions. His daily projects involve test automation and RPA across various systems. He is an open-source software enthusiast with a keen mind for problem solving. You can get his attention with a Robot Framework issue or a good sudoku.
Eftychia  Thomaidou
Eftychia Thomaidou

10 years of Robot Framework and I

🔗
04:35 PM–05:05 PM
By Eftychia Thomaidou

Ten years ago, I met Robot Framework. I was new to QA and my first thought was: “Where is the actual code?” Ten years later, after countless keywords, libraries, pipelines, Python extensions and, of course, failures, we're still together. This talk is the story of what Robot Framework taught me about clean code, reusable automation, CI/CD, debugging and community with examples of the good, the bad and the questionable. Because in the end, Robot Framework didn't just teach me how to automate tests. It taught me how to become a software engineer in testing.

Somewhere in June 2016, I joined a project as a QA Software Engineer and was introduced to Robot Framework and RIDE.
My first thought was: where is the actual code?
Then I got used to the syntax. I started writing tests. I started understanding QA. And slowly, Robot Framework and I got to know each other.
I didn't know much about QA back then and I certainly didn't know that we'd still be together 10 years later.

Ten years and several projects, architectures and environments later, I've grown up with Robot Framework.
And somewhere along the way, it taught me much more than how to automate a test.

I learned that automation code is still code. It needs to be clean, reusable and maintainable.
Tests can do more than check whether something works: they can automate a process, document behaviour and provide auditable evidence of what was tested.

And I discovered just how far I could take them.

UI testing? Robot Framework.

API testing? Robot Framework.

Databases? Robot Framework.

Kubernetes? Robot Framework.

Something weird and specific for which nobody has written a library yet?
No problem; I'll write it in Python.

But as the test suites grew, I learned some less exciting and probably more important lessons.
Not everything needs another keyword.
Hardcoded values eventually come back to haunt you. Reusability matters. Linters matter. Commit hooks matter.
CI/CD matters. And code that only you understand is not particularly useful when you're working in a team.

Robot Framework was also part of how I learned to review code, receive feedback, give constructive feedback,
share quality standards with a team and treat test automation as software that deserves the same engineering practices as production code.

And, of course, things broke. A lot.

Fortunately, Robot Framework gave me useful error messages, logs and reports that actually helped me understand why things broke.
And when those weren't enough, there was something even more valuable: the community.

Robot Framework is open source, surrounded by people building libraries, sharing solutions and helping each other. Today, its Slack community alone has more than 33,000 members.
Apparently, whenever I got stuck, I had 33,000 colleagues. They just didn't know they worked with me.

In 2027, RoboCon celebrates its 10-year anniversary. I'm celebrating one of my own: ten years since I first met Robot Framework.

This is the story of those ten years, the useful keywords, the questionable keywords, the libraries, the pipelines, the Python, the failures, the community, and the lessons I picked up along the way.

Because after ten years, I realised something:
Robot Framework didn't just teach me how to automate tests. It helped teach me how to become a software engineer.
In this talk I plan to give a few examples of the lessons I learned using Robot Framework,
like making generic functions and how they can be extended with python,
how to integrate the tests in a pipeline, and how to debug the failures

Eftychia  Thomaidou
Eftychia Thomaidou
I am a Python & QA engineer with studies in Data Science. My passion about quality, as well as my keen eye for detail, is what lead me to Testing automation and Quality Assurance. Lately, I am focusing on Security & SecDevOps. I am team player and for me team-happiness is a very important aspect for my daily work.

Community Day · 12 March

Community Day

🔗
Mar 12, 09:00 AM | 8 hrs

Free “unconference” in a classroom setting, where attendees shape the agenda at the start of the day. It’s the perfect chance to meet people before the main conference, build on the workshops from the day before, and connect with top experts from around the globe.

Work on hands-on projects, join discussions, or simply get your questions answered. The day will also feature a free introductory Robot Framework tutorial (enrollment required).