ONLINE

Worldwide 7–9 April 2027

RBCN27 ONLINE

Day 1 · Main Stage · 7 April

Online · Main Stage
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
Break
Lunch Break
Break
Break
Miikka Solmela
Miikka Solmela

Opening Session – RoboCon 2027 Online

🔗
10:00 AM–10:30 AM
By Miikka Solmela

The official opening of RoboCon 2027 Online by the Robot Framework Foundation. Tune in to kick off the conference with us!

Join us as the Robot Framework Foundation opens RoboCon 2027 Online. Tune in to this session to start the conference together and get ready for the days ahead.

More details will be announced later.

Miikka Solmela
Miikka Solmela
Miikka Solmela serves as the Executive Director of the Robot Framework Foundation, leading its mission to advance the goals of the Robot Framework community and its members. In this role, Miikka drives the foundation's agenda on all fronts, ensuring the vision and priorities of the community are realized. As a leader of various working groups, Miikka is dedicated to fostering collaboration, innovation, and growth within the Robot Framework ecosystem.
Ganesha ts
Ganesha ts
Manana Koberidze
Manana Koberidze

From Lift to Cloud With Robot Framework

🔗
10:30 AM–10:50 AM
By Ganesha ts, Manana Koberidze

Press a button, go up and down. What makes every elevator journey a smooth ride?
Modern elevators are more than machines that move people. They are connected IoT systems where devices continuously exchange data with cloud services for monitoring, diagnostics, and remote maintenance. In this talk, we'll show how Robot Framework helps us test the connected services behind every ride.
We'll walk through our test automation architecture, conventions, libraries and wrappers built around Robot Framework, and show how we use them to validate the journey from lift to cloud.

This talk presents how we use Robot Framework to test a connected elevator IoT platform spanning web applications, AWS cloud services, and connected devices.
We'll demonstrate how we validate end-to-end workflows across the UI, cloud services, and devices, and discuss challenges such as coordinating multiple devices. We'll share practical examples from a test suite of more than 1000 automated test cases.
Finally, we'll discuss lessons learned from evolving our automation solution over time, including areas we're currently exploring, such as the use of AI to support test automation activities.

Ganesha ts
Ganesha ts
Hey! I am Software Test engineer with 15+ years of experience. Loves computers, coding, languages, Music. Focusing more on making readable, maintainable and scalable automation code in the team and sharing those to newcomers.
Manana Koberidze
Manana Koberidze
I am a Senior Test Automation Specialist at [KONE Oyj](https://www.kone.com/global/en.html), Finland. I'm passionate about software quality, continuous learning, and community collaboration. At KONE, I help teams get the most out of Robot Framework by encouraging modern practices, adopting new capabilities, and supporting the modernization of test automation for connected elevator solutions and digital services. I also love being involved in the Robot Framework community and contributing to the Robot Framework workgroups whenever I can.
Florian Löhden
Florian Löhden
Sandro Vincenti
Sandro Vincenti

Readable, Repeatable, Trustworthy: Kubernetes Performance Tests with Robot Framework

🔗
11:00 AM–11:20 AM
By Florian Löhden, Sandro Vincenti

It started with running the tools by hand: one test at a time, no schedule, every result copied together manually. Then came an in-house tool, with Robot Framework checking the results at the end. The idea worked; the ecosystem around it didn't. Now the Robot suite is the test itself: criteria anyone can read, like Throughput Should Be At Least 950 megabits per second, and a parser that refuses anything it wouldn't run. Three generations of performance testing bare-metal Kubernetes clusters around the world for a financial customer: what broke, what we kept.

What does "performs as agreed" mean?

For a customer, we validate the performance of bare-metal Kubernetes clusters in data centres around the world. Every test ends with one question: does this cluster perform as agreed? The answer has to be the same, and comparable, wherever and whenever it is asked.

This talk follows how our answer evolved over three generations, and what each one taught us.

Three generations

1. By hand. We ran the tools one at a time, without a schedule, and copied every result together manually.
2. An in-house tool. It orchestrated several performance tools across scenarios and architectures. Robot Framework evaluated the results at the end and produced the verdict and the report.
3. The Robot suite is the test. We kept what worked: one orchestrator for many tools, scenarios, and Robot's verdict and report. What changed is that the suite no longer checks results afterwards. It defines the test:
- Pass criteria are keywords anyone can read, such as Throughput Should Be At Least 950 megabits per second.
- The parser only accepts what it will actually run. A criterion hidden in an ELSE branch would pass without being checked, so it is refused.
- The same test can be written in YAML, and round-trip tests keep both formats equal.
- Every performance tool plugs in behind the same interface.
- Common measurement pitfalls are closed by design: no traffic before every pod is ready, a discarded warm-up pass, missing data is never a pass, and one run per cluster at a time.

What you will take away

Bringing Robot Framework into an existing environment is much easier than we thought. You don't have to start over:

  • Start at the end. Let Robot evaluate the results your tools already produce.
  • Keep your tools. iperf2, IRTT or a customer's own tool stay as they are. Robot needs their results, not a rewrite.
  • Use the reporting you already have. Robot's verdicts and reports can go into the test reporting your customer already uses.
  • Grow one step at a time. From checking results, to readable pass criteria, to the suite being the test, and what to watch for at each step.
  • Let non-testers read it. Readable keywords let a customer review exactly what was agreed.

Who it is for

Teams with existing test tooling who wonder whether Robot Framework fits in, and anyone who has had to sign off on a performance test result.

Florian Löhden
Florian Löhden
Florian Loehden is a NetDevOps Engineer at Logicalis Connected GmbH, where he validates the performance of Kubernetes clusters in data centres around the world. He holds a Master's degree in Computer Science and is fascinated by everything around automation, DevOps and open source. He founded the NetAuto Group, a community for network automation enthusiasts covering everything from DevOps and cloud to core networking. He builds and improves tooling wherever it's needed, including the open-source performance testing tool this talk is about.
Sandro Vincenti
Sandro Vincenti
I have been working with Robot Framework and test automation for a few years now, with a strong focus on infrastructure and network testing. A large part of my previous work involved automated testing in 5G and networking environments using e.g. Cisco TRex for traffic generation. One of my main goals was to keep Robot Framework tests readable and accessible, so they could also be understood and used by people without a deep technical background. Today, I work in the financial sector, where I continue to automate tests in Kubernetes-based environments and work with CI/CD pipelines to integrate testing into automated workflows.
Lukáš Procházka
Lukáš Procházka

When Robot Framework Keywords Become a Library

🔗
12:00 PM–12:20 PM
By Lukáš Procházka

What changes when other projects start depending on your Robot Framework keywords? The challenges extend far beyond writing reusable keywords. Our libraries are implemented as Robot Framework resource files. I'll share how such a library is created, how its development and testing are supported by CI/CD, how new versions are prepared and published to a package repository, and how they then reach dozens of teams for use in their projects. I'll also show how changes to the library's source files trigger the appropriate CI/CD verification processes and how impact analysis drives test selection.

The talk starts with the problem that led us to create the library: how to share proven keywords across projects, reduce duplication, and keep their behavior consistent for dozens of teams. I'll show how that need gradually evolved into a separately maintained library.

I'll share our experience with a family of libraries whose reusable keywords are written directly in Robot Framework resource files, rather than as custom Python modules or library classes. Python remains an important part of the environment, including its third-party dependencies and packaging. The talk will compare the benefits and practical differences between a pure Python library and a library based on Robot Framework resource files, including when each approach is the best fit.

The main part follows the journey from resource files to a Python package that acts as the distributable wrapper for Robot Framework. I'll show how the library is built, prepared for installation, and how its resource files are then loaded by a consuming test project. This step connects Robot Framework authoring with the familiar process of distributing versioned packages.

The next part of the talk focuses on the CI/CD process that support this lifecycle. The entire process, from developing and reviewing a change through a pull request, including Robocop analysis, testing, or other checks, to building and distributing a new version, is automated. A change to the library source files determines the relevant test scope for the affected area of the library, and the selected tests are then executed

Audience: Robot Framework users who share keywords across projects or are considering doing so. Basic familiarity with resource files is enough; experience with implementing Python libraries is not required.

Takeaways: Experience and practical perspectives for deciding when resource files need their own lifecycle, maintaining such a library, and distributing it reliably across consuming projects.

Lukáš Procházka
Lukáš Procházka
Lukáš Procházka has over 13 years of experience in software testing and more than 8 years of experience with Robot Framework. He works at Česká spořitelna, the largest Czech bank and part of Erste Group, where he is a member of the Centre of Expertise in Testing. His primary focus is web and mobile test automation using Robot Framework and Appium. He contributes to automation architecture, proof-of-concepts, code reviews, testing standards and CI/CD integration. Lukáš is passionate about sharing practical experience and helping teams build reliable and maintainable test automation solutions.
Timo Stordell
Timo Stordell

Salesforce and Robot Framework - a match made in heaven?

🔗
12:30 PM–12:50 PM
By Timo Stordell

After working two years with Robot Framework for testing Salesforce, I’ve come to know there are quite many challenges that come with Salesforce. How to tackle those to get testing proceeding? Here’s my experiences and tips for you.

Test automation for Salesforce faces many challenges, for example:

  • How to access the elements on a UI having dynamic code?
  • How to make the testing processes reliable?
  • How to make testing faster?
  • What environments you need for testing?
  • How to prepare for unexpected changes?
  • Would AI be able to help there?

The work with such platform differs significantly from a solution implemented in-house from scratch as you won’t have control on all the content, and neither on when some of the content gets updated.

We’ve used Robot Framework for testing a new Salesforce solution that would replace company-wide legacy system. I believe the discoveries made here would be beneficial also for others wishing to do test automation for Salesforce.

Timo Stordell
Timo Stordell
I have a 30-year career in IT, with over 15 years dedicated to test automation and QA leadership across telecom, healthcare, and finance. Worked 10 years with Robot Framework, earlier a Robocon team member and a participant in all of the events. I’m a passionate pipeliner on a crusade to build the future of software development.
Tommi Oinonen
Tommi Oinonen

Run your validation keywords (asynchronously) later

🔗
02:00 PM–02:20 PM
By Tommi Oinonen

A lot of the execution time is usually spend waiting for the tested system to reach some expected state that needs to be validated. Especially with more complex systems the state propagation can take time that could be used more efficiently.

Robot runs suites and test cases synchronously and in order. Previous test/suite needs to complete before moving to the next.

What if instead of "Wait Until Keyword Succeeds" you could use something like "Run Other Tests/Keywords Until Keyword Succeeds".

If this sound good we have a library for you!

We have developed libraries in our project that allow you to postpone keyword executions and wish to open source them now. They employ couple of different approaches that can be used to both optimize some tests and make some easier to maintain.

I'll be presenting the open sourced libraries and how to use them. I'll give practical examples and explain how these concepts can be employed to simplify some tests. These methods allow you to think differently about how to implement some test scenarios. Maybe even start a discussion around the topic in the community and find more use cases.

This is not parallel execution like pabot but selective asynchronous execution with the help of listener libraries.

This is mostly about executing some tests/keywords/functions not where they are logically in the suite/test but actually later when the system is ready:
1. in the end of the suite
2. in the end of the test run
3. the next day

The results of these postponed executions can then be injected back to the test logs where they logically exist for reporting.

Real world use cases:
1. Validation requires waiting that could be spent testing something else
2. A batch job is part of the process under test. It is inefficient to run it for each test separately
- register all the validations in the tests
- run the batch job once
- run all the validations after that
3. Validation that need to wait for some long process to complete and requires checking after the initial test run e.g. the next day

Tommi Oinonen
Tommi Oinonen
Automation and DevOps tool smith with over a decade of experience with testing in non-trivial contexts like embedded testing in industry and banking processes. He has been maintaining, developing and integrating various tools, platforms and processes to enable the success of development teams. Currently a consultant with VALA.
Luis Gomez-Tinoco
Luis Gomez-Tinoco

Balancing Test Suites Across CI Workers: Bin Packing with a Robot Framework SuiteVisitor

🔗
02:30 PM–02:50 PM
By Luis Gomez-Tinoco

Running hundreds or thousands of Robot Framework tests in CI quickly becomes a scheduling problem. Running them one after another is too slow. Pabot runs tests in parallel on one VM, but every process shares the same test server and database, which soon becomes the bottleneck. Our setup gives each worker its own VM, test server and database, which raises a new question: how do you split the suites evenly between them? This talk shows how a small SuiteVisitor, built on Robot Framework's own APIs, assigns suites to workers by how many tests each one contains.

Our CI pipeline runs about 621 end-to-end tests every day, organized into 52 suites. Run one after another on a single worker, that takes about 16 hours.

The usual first step is Pabot. It works well, but it runs on one VM, and all its processes share one test server and one database. Adding processes eventually makes things slower, because that shared environment becomes the bottleneck. So we went a different way. We gave each of 7 VMs its own test server and its own database, which removes the contention completely.

That created a new problem: deciding which suites go to which VM. Splitting by suite count, N suites divided across K workers, rarely balances. A suite with 40 tests and a suite with 3 tests count the same, but they are not the same amount of work. In a CI pipeline, the slowest worker sets the pace for everyone.

This talk walks through the small, production SuiteVisitor we built to solve this. It is registered as a pre-run modifier with one command-line argument that reads as "split into N parts, run part i". Before any test runs, it sees the whole suite tree. It filters out tests that shouldn't run, such as archived tests or known defects, weighs each suite by how many tests it contains, and hands the problem to a bin-packing algorithm that spreads the suites evenly across the workers. Each VM then keeps only its own share and drops the rest. No orchestration service is needed, and no changes to the tests themselves.

We'll look at:

How the visitor pattern in Robot Framework's API makes this a low-code extension rather than a custom runner.
Why, in CI, keeping the number of workers fixed and balancing the load across them beats fixing a capacity per worker and letting the number of workers grow.
Real results: the ~16-hour run dropped to about 3 hours. The average per worker was 146 minutes against a theoretical ideal of 138.
Where it still falls short: the fastest VM finished in 1h51m and the slowest in 3h05m. Whole suites can't be split, and test count is only a stand-in for how long a suite takes, since our tests range from 15 seconds to more than 7.5 minutes.
We'll finish with the next steps and their trade-offs. Weighting suites by measured execution time is one. Splitting at the test-case level is another: it promises better balance, but you lose the reuse of suite setup and teardown. You'll leave with a pattern you can adapt to your own pipeline, and a clear sense of when it's worth going beyond Pabot.

Luis Gomez-Tinoco
Luis Gomez-Tinoco
Luis Gomez is a software developer with over 15 years of experience, currently an L4 engineer at Telus Health. Throughout his career he has built automation frameworks and tools at IBM, BlackBerry, and CBC, working across Python, Java, C/C++, C#, and Playwright. He holds a BASc in Systems and Computing Engineering, an MBA, and an MS in Computer Science, and is a contributor to the Robot Framework Browser library. Outside of work, Luis is an avid hiker: he's walked the final 150 km of the Camino Portugués, climbed the two highest peaks in New York State, and trekked to Ciudad Perdida (the Lost City) in Colombia's Sierra Nevada de Santa Marta. He's a proud father of two adult children, grandfather to Pumba the dog, and partner to Nora.
Jeff King
Jeff King

You can change career paths but you can't quit Robot Framework

🔗
04:00 PM–04:20 PM
By Jeff King

Two brothers took separate paths to Quality Engineering and with the changing technology landscape, both now have roles that don't have "Quality" in the title but are still Robot Framework users.

Jeff King has 20+ users in manual and automated testing and is now a Customer Success Manager.
Ryan King has 10+ years in testing and is now a Software Engineer.

Both are still avid Robot Framework users, thanks to its versatility and ease of use.

UPDATE: We would like to do this presentation with 2 speakers - one as noted before and another who is now a software engineer who has developed a Claude skill to build Browser library Robot Framework tests into the deployment process. His notes will be in "Notes"

This talk will discuss the versatility of Robot Framework and how it can be used with AI tools.
The strengths of Robot Framework/Python and creating custom libraries, including with Claude.

Projects I've done related to a given issue:
Chaos Bot - geared toward testing Angular to Vue migration - ended up finding some bugs but more security issues.
API Test Replicator - the ability to "play" previous API data and re-run vs. replicated/test environment for trouble shooting.
Robot Framework to Artillery exporter - we wanted to be able to take API traffic and use with Artillery as our load test.
And as a "Customer Success" manager - I wrote a full API suite and tested it verses our documentation using Claude to generate tests based on reading the documentation.

Why do I choose to use Robot Framework when other tools are available?
Robot Framework and AI tools work well together - I can hand it a product design and get a vibe-coded function either as tests case with an existing library or creating a totally new library and they will work quickly.
Robot Framework does a better job of error/exception handling than other tools. Putting conditions on data/page states/etc. can be added at any point - other tools may stop the moment they get something they 'don't expect'.
Robot Framework is not just a familiar tool, but an easy one. I've gotten more into the world of API testing and used new tools for Graph QL and Rest testing.
Robot Framework is a great tool for generating output as test results, lists, data for other tests, even using Robot Framework to build new, repeatable tests from reviewing options that appear on a page!

Jeff King
Jeff King
Jeff King is a Quality Assurance engineer from the Boston/New York (Connecticut) area of the United States. Jeff has approximately 20 years QA experience in the financial, theater/live arts and specialty insurance industry, transitioning from manual to automated testing during that time. Jeff is married to wife, Carrie, and has two children Josh and Megan. He is also a hiker and musician and has published one fiction novel and is currently on a quest to run a race in all 169 towns of his home state of Connecticut.
Many Kasiriha
Many Kasiriha

AI panel: how does AI change our work and our relevance?

🔗
05:00 PM–06:00 PM
By Many Kasiriha

A moderated panel discussion on AI. Speaker to be announced.

A moderated panel discussion on AI. Speaker to be announced.

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

Day 2 · Community Tracks · 8 April

Community Stage
Workshop 1
Workshop 2
10:00
10:30
11:00
11:30
12:00
12:30
13:00
13:30
Break
Break
Break
Many KasirihaMany Kasiriha

Intro to AI engineering with RF

🔗
10:00 AM–11:00 AMMany Kasiriha

A practical introduction to AI-assisted work with Robot Framework using the stack the community recommends: RobotCode and Agent Skills. Many shows how to set it up and use it, in conversation with AI track chair Guido Demmenie.

AI coding agents can write, run and fix Robot Framework tests, but there are many ways to set them up. This session shows the one we recommend: RobotCode together with Agent Skills.

Many walks through the setup and a live demo, talks about what works and what to watch out for, and introduces Robot Framework Plugins, a shared repository of agent skills that anyone can use and contribute to. The session is a conversation with Guido, with room for your questions.

No prior AI experience needed. More details to be added.

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 Library API

🔗
10:00 AM–02:00 PMPekka Klärck

In this hands-on online workshop, Robot Framework creator Pekka Klärck takes you beyond the basics of the library API. You learn how to build more powerful and flexible keyword libraries in Python using features such as automatic argument type conversion and the dynamic library interface.

This half-day online workshop focuses on the more advanced parts of the Robot Framework library API. We cover topics such as automatic argument type conversion and the dynamic library interface used, for example, by SeleniumLibrary, and how to use them to build libraries that are powerful and easy to use.

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.

This workshop is one of two independent half-day workshops on extending Robot Framework. The other one, "Extending Robot Framework: Listeners and Modifiers", covers the listener API and modifying tests and results. You can join either one or both.

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

  • Advanced library API: automatic argument type conversion
  • The dynamic library interface
  • Hands-on exercises throughout, with time for questions

Preparation and technical requirements

  • A computer with a stable internet connection, able to join the online workshop session
  • 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)
  • 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 session, but you can also download it as a zip.

Key takeaways

  • Use automatic argument type conversion in your own libraries
  • Build libraries with the dynamic library interface
  • Design keyword libraries that are powerful and easy to use
  • Gain a deeper understanding of how Robot Framework uses libraries
  • Hands-on experience directly from the framework's creator
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.
Robert JadoenandansingRobert Jadoenandansing
Karan92Karan92

Testing AI Agents with Robot Framework: Deterministic Evidence for Probabilistic Systems

🔗
11:15 AM–11:45 AMRobert JadoenandansingKaran92

AI agents are probabilistic. Test automation is expected to give deterministic evidence. So what happens when we need to test an agent that uses LLMs, RAG, APIs and tools? In this talk I show how Robot Framework can become the control and evidence layer around AI systems: Validating tool use, schemas, sources, guardrails and outcomes while keeping LLM-based evaluation in its proper place. You will leave with a practical pattern for testing AI without letting the AI decide whether it passed.

Large language models make modern AI systems powerful, but they also introduce a testing problem: The same input can produce different outputs, while our pipelines still need an objective PASS or FAIL.

This talk shows a practical way to use Robot Framework as the deterministic control and evidence layer around an AI agent. Instead of asking another LLM whether a result "looks correct", we separate what can be tested deterministically from what genuinely requires probabilistic evaluation.

Using a small agentic/RAG example, I will show Robot Framework tests for:
- API and output-schema validation
- Verifying which tools were called and with which arguments
- Validating retrieved sources and citations
- Checking guardrails and forbidden actions
- Collecting execution evidence for CI
- Combining deterministic assertions with semantic or LLM-based evaluation where appropriate

We will also look at failure modes that are easy to miss: A fluent but unsupported answer, a correct answer produced through the wrong tool, an LLM judge that changes its verdict between runs and a self-repair mechanism that hides a real regression.

The goal is not to make Robot Framework "AI-powered". The goal is to use the strengths Robot Framework already has readable test cases, reusable keywords, libraries, reporting and deterministic assertions to make AI systems more testable.

Attendees will leave with an architecture they can apply immediately: What to assert in Robot Framework, what evidence to capture, where probabilistic evaluation belongs and where it should never be allowed to decide PASS or FAIL on its own.

Audience: Robot Framework users, test automation engineers and developers who are beginning to test LLM-, RAG-, MCP- or agent-based systems. No deep machine-learning knowledge is required.

Robert Jadoenandansing
Robert Jadoenandansing
Robert Jadoenandansing is an AI, Machine Learning and Quality Engineering specialist, with a strong focus on Generative AI, Large Language Models, agentic systems and the practical application of AI in software engineering. His background spans machine learning, deep learning, test automation and quality engineering, allowing him to approach AI from both a technical and engineering perspective. He is particularly interested in how LLMs and AI agents can be evaluated, controlled and integrated into real-world software development and testing workflows. Robert also leads an Academy, where he develops and delivers training on AI, test automation and modern quality engineering. As a speaker and trainer, he focuses on moving beyond AI hype: Understanding what these systems can actually do, where they fail, how their behaviour can be measured, and how deterministic engineering practices can be combined with probabilistic AI systems. His current work explores topics such as LLM evaluation, AI agents, RAG, MCP, AI-assisted software engineering and the changing role of quality engineering in an increasingly AI-driven development landscape.
Karan92
Karan92
Many KasirihaMany Kasiriha
Guido DemmenieGuido Demmenie

Testing AI Solutions: An Open Discussion

🔗
11:45 AM–12:45 PMMany KasirihaGuido Demmenie

How do you test a system that never gives the same answer twice? Following the talk "Testing AI agents with Robot Framework", this open session continues the conversation: how to evaluate AI solutions, from chatbots and AI-driven decisions to coding agents, agent skills and MCP servers, with and without Robot Framework. Bring your experiences, questions and ideas.

AI is finding its way into more and more systems, and they all need testing. This session continues from the talk "Testing AI agents with Robot Framework: deterministic evidence for probabilistic systems" and widens the view to evaluating AI solutions in general, with and without Robot Framework.

We look at two kinds of AI solutions:
- Systems with AI capabilities, such as chatbots and systems that make decisions or give recommendations based on AI
- Coding harnesses: a coding agent combined with agent skills and MCP servers

Topics for discussion include:
- Do we really need to test these systems, even when the solution is "just Markdown", as with agent skills?
- The challenges: non-deterministic results, cost, and knowing when a result is good enough
- Practical approaches and examples from the community

This is not about presenting "the best way" to do it, but about exchanging ideas. Many Kasiriha and Guido Demmenie moderate the session and share some of their own challenges in testing MCP servers and agent skills as discussion starters, but most of the time is for you: your experiences, your questions and your approaches.

Who is this for?
Anyone who is testing, or about to test, AI-based systems, whether you use Robot Framework or not.

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
Guido Demmenie
Guido Demmenie
Guido Demmenie is a RFCP Certified Test Automation Architect, trainer and coach with years of experience implementing and using Robot Framework. He has a strong focus on knowledge transfer on the job and by being part of the organising team for RF-NL and co-hosting on online platforms focused on Robot Framework.
René RohnerRené Rohner

The role of test automation in the age of AI

🔗
01:00 PM–01:30 PMRené Rohner

AI agents can write code, but who decides whether it does the right thing? Discover how Robot Framework’s readable, keyword-driven tests turn human expectations into executable contracts—and give coding agents a reliable feedback loop. Learn where agents help, what makes a test stack agent-ready, and why people still own quality.

Faster code generation does not automatically mean faster delivery—or the right product. As coding agents take on implementation, clear expectations and trustworthy verification become even more important.

Robot Framework’s readable, keyword-driven approach provides a valuable boundary: people define the expected behaviour in business-level tests, while agents help implement and maintain the technical keywords underneath. Those tests become executable domain knowledge that humans can discuss, review, and reuse across changing implementations.

This talk explores how to build on that foundation:

  • Separate readable acceptance criteria from technical implementation.
  • Use Robot Framework tests as feedback for coding agents.
  • Assess readiness: command-line execution, accessible environments, machine-readable results, and maintainable libraries.
  • Move from AI-assisted coding towards a closed agentic feedback loop.
  • Check the tests themselves, avoiding the trap of agents generating code and tests that share the same misunderstanding.

Through keyword examples and a practical workflow, you will see where agents can reduce effort—and where human judgment remains essential.

You will leave with a clearer way to position Robot Framework in an AI-enabled development workflow: not merely as a test runner, but as a readable contract between intent, implementation, and verification.

AI can take on the work. People still own the expectations, the evidence, and the decision to release.

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.
Community Stage
WorkAdventure Stage
Workshop 1
14:00
14:30
15:00
15:30
16:00
16:30
17:00
17:30
18:00
Break
Break
Break
Break
Break
Dave AmiesDave Amies

Choosing Test Cases for RFSwarm

🔗
02:00 PM–02:45 PMDave Amies

You need to do performance or load testing testing for your application, you have a full suite of robot framework tests cases and so you decide using RFSwarm might be a good idea, but now your not sure:
- Which test cases should you chose?
- How do I justify which ones I chose and which ones I chose not to use?
- how many robots should I assign to each test?
- how long should I run the test for?

This talk will be a practical guide to how to get started with performance testing, while it will be targeted for people who have been tasked with doing performance testing and don't know how to get started, it will also hopefully have practical gems for everyone.

Dave Amies
Dave Amies
I am a performance testing professional who created RFSwarm to reduce the duplication of test development in test automation between functional and performance testing.
Pekka KlärckPekka Klärck

Start Contributing to Robot Framework Core

🔗
02:00 PM–02:30 PMPekka Klärck

Want to help shape the future of Robot Framework? This session shows you how to get started contributing to Robot Framework core: where the work happens, how contributions are made, and where to find help. Come hear why contributing is worth it, and join the discussion about how you can get involved.

Robot Framework is open source, and its future depends on the people who contribute to it. This session is for everyone who has thought about contributing to Robot Framework core but has not known where to start.

We cover the practical side of contributing: where development happens, which communication channels to follow, how issues and pull requests are handled, and what kinds of contributions are needed, from code and tests to documentation such as the Robot Framework User Manual. You will also hear why contributing is valuable, both for the project and for you.

The session continues from "Robot Framework core architecture" and ends with an open discussion, where you can ask questions and talk about how you could get involved.

Who is this for?

Robot Framework users and developers who are interested in contributing to Robot Framework core. No previous open source experience is needed.

Key takeaways

  • Know where Robot Framework core development happens and how to follow it
  • Understand how contributions are made, from issues to pull requests
  • Know which kinds of contributions are needed, beyond code
  • Know where to get help when you get started
  • Take your first step towards becoming a Robot Framework contributor
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.
Kelby StineKelby Stine

Building A Robot Framework Project From the Test Upwards with Agents in Mind

🔗
02:00 PM–06:00 PMKelby Stine

This is a re-vamp of my previous online tutorial for building an automation project from the test upwards. Building off of best practices of managing dependencies, tests/tasks, and resources.

Building a project seems difficult, but with a process that starts with the test case an automation developer can result in a model that is flexible and scalable.

Dependency management
Fundamental directory design.
Tools to consider.
Workflow from test case, to test suite, to resource creation, and finally custom libraries
How to further integrate test cases
Introduce a product centric design pattern

This is a working session where an attendee can start with nothing but a empty repo and walk out with a fully structured automation project for Robot Framework.

Key topics to cover will be:
- managing dependencies
- IDE tooling
- What Libraries?
- Using variables wisely
- Levels of Keyword Abstraction
- How to create the project to be Agentic friendly
- There may be references to gnomes and possibly pancakes

Kelby Stine
Kelby Stine
Known for past Robocon talks such as: "Pancakes as Testing" – 2026 “I Hate Robot Framework” – 2025 a workshop called “Building a Project from the Test Upwards” – 2025 “Robot Framework Is...” – 2024 “You got Robot Framework in my Python” – 2023 “Robot Framework Is Not ...” – 2022 I have been involved in the Robot Framework Style Guide Work Group for 4 years. Music Composer with a passion for technology (and a decent paycheck). I have been working for software development companies for 19 years. Automation has been my core focus for the last 11 years utilizing various scripting tools and languages for tests and other processes. I am an avid sourdough bread baker, pancake maker, and an active musician in my area playing Horn (French Horn) and British Tenor Horn. My happy place is writing and arranging music for the groups I play. While not officially diagnosed, I am a gnome-a-holic and do not plan to go into any recovery program for the malady.
Pekka KlärckPekka Klärck

Ask the Creator: Open Q&A and Feature Ideas with Pekka Klärck

🔗
02:30 PM–03:30 PMPekka Klärck

TBA: Ask Pekka Anything + feature ideas. Ask Pekka Anything + feature ideas

Ask Pekka Anything + feature ideasAsk Pekka Anything + feature ideasAsk Pekka Anything + feature ideasAsk Pekka Anything + feature ideasAsk Pekka Anything + feature ideasAsk Pekka Anything + feature ideas

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.
Dirk O. SchweierDirk O. Schweier

Generating High-Quality Test Data During Test Execution

🔗
03:00 PM–03:30 PMDirk O. Schweier

“Yeah, why don’t you just generate some test data?”
If you’ve heard this or something similar during a project, you’ve probably also experienced how time-consuming it was to generate the right test data.
Software systems, for example, validate whether a ZIP code and city match during data entry. The more checks there are, the more test cases fail - not because the software has a bug, but because incorrect test data is being used.
With the SynData library, you can generate random test data that is consistent at the time of test execution, and the test cases can be easily rerun using the logs.

Test data is required in almost every project. The requirements that projects place on test data vary greatly in terms of the data that must be included in the dataset and the structure of the individual data points.

Because of these differences, I have almost always written scripts for my projects that allowed me to generate test data as files. However, these files weren’t always helpful when it turned out that the test data could only be used once or had an expiration date due to date specifications.

During open space sessions at Robocon, it became clear that many test automation engineers face this problem. It also became evident that everyone is pursuing their own solutions to some extent, since the Robot Framework ecosystem doesn’t offer a suitable solution. When we discussed what we wanted from a solution, the following ideas were put forward:
* The data should be consistent.
* The library should be able to “remember” data generated during a test so that the test automation engineer has to work with variables as little as possible.
* A test case should be as easy as possible to repeat using the data that was randomly generated during a previous test execution.

These ideas can only be implemented if the architecture takes them into account, which is why I decided - hopefully for the last time - to write a script based on these ideas as requirements and that has reusability, at least within the Robot Framework ecosystem.

The SynData library is based on a dataset initially compiled for Germany, from which results can then be randomly generated. However, using the keyword parameters, the user can also filter the data in advance to, for example, obtain a license plate for a specific city or from a particular federal state.

The user can also set a context using a keyword. This saves the results of the keywords in the library, and when a keyword requests data related to previously generated data, the result is determined from a filtered set - so that, for example, the address matches the license plate that was previously generated for the context.

The SynData library can generate a log of the generated data during test execution. If such a file is specified when initializing the library, a test case can be re-run without further modification, and the library will return exactly the values from the keywords that are taken from the log.

In my talk at Robocon, I would like to introduce the library to a broad audience, as I am convinced that it will be helpful to many test automation engineers and that, with the involvement of additional experts, other regions can also be better supported.

Dirk O. Schweier
Dirk O. Schweier
As a freelancer, I support my customers in test automation, performance testing and test management.
Marduk BolanosMarduk Bolanos

Five years of robosapiens and the future of SAP automation for humans

🔗
03:45 PM–05:30 PMMarduk Bolanos

robosapiens has become the standard library for automating the SAP GUI with Robot Framework.
It has been downloaded over a 100k times and is being used all around the world. In this talk I will showcase its new recording capabilities, which radically change the way robosapiens is used. I will also present the current advances in bringing the ideas of robosapiens to the browser for automating SAP UI5. 2027 is a transition year for SAP users and now is the best time to get to know robosapiens!

robosapiens started life in 2021 as an internal project at NRW.BANK and became publicly available in 2023. The initial motivation was to allow domain experts to automate their tests using the texts they see on screen. No inspector needed. Nowadays they can directly record their tests and robosapiens will write the .robot file for them. This is a huge time saver and also serves as a way of documenting processes. The generated HTML report resembles a .robot file, which makes it easy to read, and includes the screenshots of all windows. Previously such documentation was generated using the Windows Recorder, which is no longer available on Windows 11. By the end of 2027 SAP will no longer support its Solution Manager and with it CBTA, the test automation tool for domain experts that allows recording test cases in terms of reusable components. Moreover, SAP will also end support for SAP ECC, the third generation of its ERP Platform. This means customers have to migrate to SAP S4/HANA and regression tests will be vital to the success of that migration. For these reasons, 2027 is the best time to get to know robosapiens!

Marduk Bolanos
Marduk Bolanos
Marduk is a Senior Software Quality Engineer at imbus and a perfectionist as defined by Saint-Exupéry. He is passionate about creating simple software that empowers people to use a computer as the tool they need it to be. Best known as the author of robosapiens and KeyTA, he also enjoys giving talks and workshops.
Thomas RaffelsieperThomas Raffelsieper

I didn't write a single line: building a Robot Framework platform with AI agents

🔗
03:45 PM–04:45 PMThomas Raffelsieper

What happens when you build a full Robot Framework platform without typing a single line of code? For seven months of evenings I only steered and reviewed AI coding agents. The result is RoboScope: a visual flow editor, recorder, self-healing, isolated environments, offline mode. First pure vibe coding, then the structured BMAD agent workflow. I'll show what worked, what broke, and the one habit that kept it sustainable: turn every AI mistake into a written rule plus a test that pins it.

RoboScope started as an after-work experiment: can AI coding agents build a serious Robot Framework tool, not a todo app, if I only steer and review and never type code myself?

Seven months later it is an open-source web platform for Robot Framework teams: Git integration, a visual flow editor that round-trips .robot files safely, a browser recorder with robust locator synthesis, an opt-in self-healing library, execution in isolated venv or Docker environments, reports and statistics, and a fully offline mode. Every line was written by Claude Code and reviewed by me.

This talk is the honest story of how that went.

Phase 1: vibe coding. For the first eight weeks I prompted, looked and accepted. It was surprisingly fast and the first releases shipped quickly. But the agent kept repeating the same classes of mistakes, some of them subtle and very specific to Robot Framework.

Phase 2: structure with BMAD. Then I added the BMAD Method: specialised agent roles (product manager, architect, story writer, developer, adversarial reviewer, retrospective) with explicit hand-offs. I'll show where that clearly paid off, for example an adversarial review that caught a deny-list bypass allowing code execution through run arguments, and where it was overhead or created a false sense of progress, like a sprint tracker that marked work "done" before it existed.

The lesson that transfers. Every recurring AI mistake became a written rule in the agent's project memory plus a test or CI gate that pins it. I'll walk through real examples from the Robot Framework domain:

  • keeping a GUI from corrupting RF syntax on a .robot round trip
  • making recorded flows survive real-world pages (wait_until, Shadow DOM, strict-mode-safe locators)
  • keeping self-healing as reviewable suggestions instead of silent rewrites
  • treating the running suite model, not the file, as the source of truth

You will take away:

  • a realistic picture of what AI coding agents can and cannot do for Robot Framework tooling, from someone who did not type the code
  • when a structured agent workflow pays off compared to plain vibe coding, and when it doesn't
  • a simple, reusable pattern to stop the same AI mistake from coming back
  • concrete RF pitfalls to guard against in your own libraries and tools

Audience: Robot Framework users, library and tool authors, and test leads who use or consider AI coding assistants. No prior knowledge of RoboScope or BMAD needed.

Thomas Raffelsieper
Thomas Raffelsieper
Thomas Raffelsieper has been a Senior Consultant and Software Architect at viadee Unternehmensberatung AG in Dortmund since 2011, working where software development, quality assurance and organisational development meet. He leads the Robot Framework User Group Dortmund, is responsible for viadee's test automation tool mateo, and develops the open-source tool RoboScope. Since generative AI emerged, he has been putting AI agents to work in everyday project practice, from Claude Code to methodology frameworks such as BMAD, Spec Kit and GSD. In his spare time he plays bass in the band Wasted Maniacs.
Many KasirihaMany Kasiriha
Guido DemmenieGuido Demmenie

Let's talk AI: where is AI taking Robot Framework?

🔗
05:15 PM–06:15 PMMany KasirihaGuido Demmenie

_Where is AI taking Robot Framework, and where is it taking our work?_

In this open round table discussion, we explore the directions AI is steering us, both the broad trends we all see coming and the personal views, hands-on experiences, and struggles we've each faced amid the rapid wave of changes of recent years.

This is an open invitation: everyone is welcome to join the conversation and share their stories, ideas, and perspectives on how AI is reshaping test automation.

Let's talk AI: where is AI taking Robot Framework?Let's talk AI: where is AI taking Robot Framework?Let's talk AI: where is AI taking Robot Framework?Let's talk AI: where is AI taking Robot Framework?Let's talk AI: where is AI taking Robot Framework?Let's talk AI: where is AI taking Robot Framework?

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
Guido Demmenie
Guido Demmenie
Guido Demmenie is a RFCP Certified Test Automation Architect, trainer and coach with years of experience implementing and using Robot Framework. He has a strong focus on knowledge transfer on the job and by being part of the organising team for RF-NL and co-hosting on online platforms focused on Robot Framework.
Pekka KlärckPekka Klärck

Inside Robot Framework: Core Architecture Explained

🔗
05:45 PM–06:30 PMPekka Klärck

How does Robot Framework actually work under the hood? In this session, Robot Framework creator Pekka Klärck walks through the internal architecture of Robot Framework core: its main building blocks and how they fit together. The recorded talk is followed by live Q&A with Pekka.

Robot Framework is used by thousands of teams, but few people know what happens inside the framework when tests are run. In this session, Pekka Klärck, the creator of Robot Framework, gives an overview of the internal architecture of Robot Framework core: the main components, how they work together, and the design ideas behind them.

The focus is on the big picture rather than on implementation details that change over time. The goal is to give you a mental map of the codebase that makes it easier to understand how Robot Framework behaves, to debug problems, and to find your way around the source code.

The session is a recorded talk followed by live Q&A, where you can ask Pekka your questions directly.

Who is this for?

Anyone curious about how Robot Framework works internally, and especially those interested in contributing to Robot Framework core. The session is a natural starting point for "Start contributing to RF core", which follows it in the program.

Key takeaways

  • Understand the overall architecture of Robot Framework core
  • Know the main components and how they work together
  • Understand the design ideas behind the framework
  • Find your way around the source code more easily
  • Get your questions answered by the framework's creator
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.

Day 3 · Community Tracks · 9 April

Community Stage
WorkAdventure Stage
Workshop 1
10:00
10:30
11:00
11:30
12:00
12:30
13:00
13:30
Break
Break
Talk TBA
Linda van de VoorenLinda van de Vooren

A Beginner's Guide to RF (from someone still

🔗
10:00 AM–10:30 AMLinda van de Vooren

TBA A Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone still

A Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone still

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).
Pieter WesselingPieter Wesseling

A Relative DateTime Library: make testing with date/time easy

🔗
10:00 AM–10:30 AMPieter Wesseling

Getting the current date and time in a test is easy. Working with dates in the future or past is more challenging.

You may need to set a date, add to it, compare dates, handle different time zones, or account for daylight saving time. The Relative DateTime library makes these tasks easy. It handles dates relative to the execution date or at a fixed point in time. It can also determine the next or previous business day and account for bank holidays. Working with dates and time should not be hard and with the Relative DateTime Library it not anymore.

Working with dates and times in Robot Framework tests can be challenging.

You never know exactly when a test will run, especially when your SUT depends on dates. You need to make sure dates are handled correctly, and there are many possible approaches, such as freezing time or time travel. But sometimes those approaches are not possible. You need to work with the current date and time.

That is where the Relative DateTime library, which we built for our project, comes in: it makes it easy to handle all kinds of dates and times. It uses a relative date-time format that is easy to read, such as +0,+0,+0,+0,+0,+0 for the current date and time or 2026,2,12,8,30,0 for a specific date and time. It offers functions to add days or hours to a date, compare dates, and account for non-working days and holidays when adding days. It also handles time zones and daylight saving time.

Do you need to select the first day of a month three months ago, the next hour today, or the next business day? The Relative DateTime library can handle this with one keyword.

We have used the Relative DateTime library in our project for many years, and we no longer have date-related problems. No more nightmares involving daylight saving time, time zones, weekends, or holidays. Just define the dates you need in a relative format, and your date-related troubles are history.

Pieter Wesseling
Pieter Wesseling
I'm working as a test automation expert for EDSN, a company that stores and processes energy data for the Netherlands. As a member of a system team I support the testers of other team by e.g. with the maintance and improvement of our test framework and enable the dialy runs of the testscripts. I'm living in Assen (The Netherlands) with my wife and 3 childeren. Withing the RobotFramework community I'm active in the RFCP Exam Committee.
Pekka KlärckPekka Klärck

Extending Robot Framework: Listeners and Modifiers

🔗
10:00 AM–02:00 PMPekka Klärck

In this hands-on online workshop, Robot Framework creator Pekka Klärck shows you how to extend and integrate Robot Framework beyond keyword libraries. You learn to use the listener API to react to test execution, to modify tests dynamically before or during execution, and to analyze and customize results programmatically.

This half-day online workshop covers ways to extend and integrate Robot Framework beyond keyword libraries. We start with the listener API, which lets you observe and react to test execution, for example to integrate with external systems or add custom reporting. We then look at data and result modifiers: how to modify tests dynamically before or during execution, and how to analyze and customize results using Robot Framework's execution and result models.

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.

This workshop is one of two independent half-day workshops on extending Robot Framework. The other one, "Extending Robot Framework: Advanced Library API", covers advanced library features. You can join either one or both. You do not need to take the library workshop first.

Knowledge level: Intermediate to Advanced

This workshop is for you if you already know the basics of using Robot Framework and want to take your skills to the next level. You should know Python basics such as functions, modules and classes. Experience in creating simple keyword libraries in Python is helpful.

Agenda

  • Listeners: observing and reacting to test execution with the listener API
  • Modifying tests dynamically before or during execution
  • Analyzing and customizing test results programmatically
  • Hands-on exercises throughout, with time for questions

Preparation and technical requirements

  • A computer with a stable internet connection, able to join the online workshop session
  • 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 session, but you can also download it as a zip.

Key takeaways

  • Use the listener API to observe and react to test execution
  • Modify tests dynamically before or during execution
  • Analyze and customize test results programmatically
  • Understand Robot Framework's execution and result models
  • Hands-on experience directly from the framework's creator
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.
Linda van de VoorenLinda van de Vooren

Too afraid to ask: Beginner edition

🔗
10:30 AM–11:30 AMLinda van de Vooren

TBA Too afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner edition

Too afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner edition

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).
Elout van LeeuwenElout van Leeuwen

Let’s talk libraries, tools & data

🔗
10:30 AM–11:30 AMElout van Leeuwen

New libraries, clever tools and smarter ways to handle test data: the Robot Framework ecosystem keeps growing. Join this open discussion to share what you use, what you have built and what you are still missing. Hosted by Elout van Leeuwen.

The strength of Robot Framework lies in its ecosystem: the libraries, tools and data solutions built and shared by the community. This session is an open discussion in WorkAdventure, following the talks in the Libraries, Tools & Data track.

To get things going, a few invited community members, such as library and tool maintainers, start the discussion. Then the floor is open to everyone. Bring your questions about the talks you just saw, share the libraries and tools that make your work easier, show what you have built yourself, or tell us what you are still missing.

Whether you maintain a library, are thinking about creating one, or just want to find the right tools for your project, this is the place to talk with others who care about the Robot Framework ecosystem.

The session is hosted by Elout van Leeuwen and is not recorded, so feel free to speak openly.

Elout van Leeuwen
Elout van Leeuwen
Elout van Leeuwen is a RFCP certified Test Automation specialist, trainer and manager with years of Robot Framework experience. He has a strong focus on scalable automation strategies. Elout brings a unique blend of technical precision and human connection to every project and presentation. He is a board member of the Foundation and an ambassador for Robot Framework.
Elout van LeeuwenElout van Leeuwen

AI is killing you softly

🔗
11:45 AM–12:30 PMElout van Leeuwen

AI. Yes, again. When I started out over 10 years ago, we could turn to stack overflow, but the brightest minds of the community were all gathered at the Robot Framework Slack. You asked questions, and you got then questions back or answers from a community member. This matters because it was really engaging, sharpening minds, bringing ideas and encouraging those who started out. But now? You ask a machine and it will spit out the most likely answer. It's like instant ramen: it'll fill you up, but nothing near an artisan made. What does it require from us to keep community alive?

Community is what keeps Robot Framework afloat. This session is to inspire us all and be reminded of the fact that we have to treasure this. To treasure is to invest. It may be okay to use your AI of choice - don't we all sometimes - but then again, how does that help the community? 10 years ago at the first conference, the world looked a whole lot different. But now we have to step up our game and make conscious decisions about how we want to learn.
I hope to convey some insights on how you on what the community needs to stay afloat and ways how you can contribute to it with our most valuable posessions: Time and Brainpower. You want something in Return? You become part of the community.

Elout opens with his thoughts, followed by an open discussion in WorkAdventure hosted by Guido Demmenie.

Elout van Leeuwen
Elout van Leeuwen
Elout van Leeuwen is a RFCP certified Test Automation specialist, trainer and manager with years of Robot Framework experience. He has a strong focus on scalable automation strategies. Elout brings a unique blend of technical precision and human connection to every project and presentation. He is a board member of the Foundation and an ambassador for Robot Framework.
Paul TurchinetzPaul Turchinetz

Write Once, Test Twice: Sharing Keywords Across Web and Windows

🔗
12:15 PM–12:45 PMPaul Turchinetz

Teams that test both a web app and a Windows app usually keep two sets of keywords for the same behaviors: logging in, opening a record, checking a total. The tests say the same thing twice, in two vocabularies that drift apart. This talk shows one behavioral keyword layer over existing web and Windows libraries, so a single test runs against both. The interesting part is where it breaks: launching the app, reading text and timing don't unify cleanly. Leave knowing which keywords can be shared, which can't, and how to tell the difference in your own suite.

Many products ship as both a web app and a Windows app. The behaviors under test are the same, but the automation isn't: one suite written against a web library, another against a desktop library, each with its own keywords for the same actions. Every new feature gets tested twice, and the two suites slowly stop agreeing on what the product does.

This talk shows a technique for writing the test once.

Find the shared vocabulary. Start from the behaviors, not the libraries. We'll take tests from both suites and work out which keywords describe what the user is doing and which describe how one platform does it.

Build one layer over two libraries. The shared keywords sit on top of your web library and your Windows library, with the platform chosen when the suite runs. An adapter can implement the same small keyword contract, so that the test file doesn't change.

Learn where it leaks. Some things don't unify: locators, windows versus tabs, timing, and controls that exist on only one platform. We'll go through some examples and what each one taught us about where the shared layer should stop.

Design the escape hatch. A shared layer that pretends the platforms are identical is worse than none. We'll cover how to drop to platform-specific keywords deliberately, without it spreading through the suite.

Paul Turchinetz
Paul Turchinetz
Paul is a software developer and tester with over a decade of experience working in large and small systems. He loves automating everything he can and investigating everything he can't. He's passionate about the art of bridging gaps - whether that's in code, processes, or collaboration.
Sander van BeekSander van Beek

Let's challenge existing good practices

🔗
01:00 PM–02:00 PMSander van Beek

TBA Let's challenge existing good practicesvLet's challenge existing good practicesvLet's challenge existing good practicesLet's challenge existing good practices

Let's challenge existing good practicesLet's challenge existing good practicesLet's challenge existing good practicesLet's challenge existing good practicesLet's challenge existing good practices

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.
Online · WorkAdventure Stage
14:00
14:30
15:00
15:30
16:00
16:30
17:00
17:30

Open-Space

🔗
02:00 PM–06:00 PM

This is your time to set the agenda. Open-Space is a free “unconference,” where attendees propose and vote on topics at the start. It’s a vibrant, hands-on space for sharing ideas, learning, and getting direct help from experts in the ecosystem. Everyone is welcome!