Public Review of the Robot Framework Certified Professional® Syllabus

Welcome to the public review of the Robot Framework® Certified Professional certification syllabus.

We are seeking feedback from the community to ensure this syllabus meets the highest standards and addresses the needs of Robot Framework professionals. While the topics have been largely finalized internally, we welcome suggestions and insights to refine and improve the content.

If you have feedback or ideas, please participate by opening an issue or commenting directly on the pull request linked below: Comment on the Pull Request

When providing feedback, please be as detailed as possible and explain your suggestions clearly. If you have a specific proposal, we encourage you to use GitHub’s proposal features to submit it directly. Your input is invaluable to making this certification syllabus comprehensive and effective.

Table of Contents

• 0 Course Overview
  • 0.1 About the Syllabus
  • 0.2 About "Robot Framework Certified Professional®"
  • 0.3 Business Outcomes
  • 0.4 About Learning Objectives and Knowledge Levels
  • 0.5 About Professional Training Providers
  • 0.6 About Exam Providers
• 1 Introduction to Robot Framework
  • 1.1 Purpose / Use-Cases
    • LO-XX Recall the two main Use-Cases of Robot Framework (K1)
    • 1.1.1 Test Automation
      • LO-XX recall the test levels Robot Framework is mostly used for (K1)
      • 1.1.1.1 Synthetic Monitoring
    • 1.1.2 Robotic Process Automation (RPA)
  • 1.2 Architecture of Robot Framework
    • 1.2.1 Robot Framework and the gTAA (Generic Test Automation Architecture)
      • LO-XX Recall the layers of the Generic Test Automation Architecture (gTAA) and their corresponding components in Robot Framework (K1)
    • 1.2.2 What is Robot Framework & What It Is Not
      • LO-XX Recall what is part of Robot Framework and what is not (K1)
    • 1.2.3 Technology & Prerequisites
      • LO-XX Recall the technology Robot Framework is built on and the prerequisites for running it (K1)
  • 1.3 Basic Syntax & Structure
    • LO-XX Recall the key attributes of the syntax that makes Robot Framework simple and human-readable (K1)
    • 1.3.1 What are Test Cases / Tasks?
    • 1.3.2 Files & Directories
    • 1.3.3 What are Keywords?
      • LO-XX Explain the difference between User Keywords and Library Keywords (K2)
    • 1.3.4 Resource Files & Libraries
      • LO-XX Recall the difference between Resource Files and Libraries and their artefacts (K1)
  • 1.4 Specification Styles
    • LO-XX Recall the three specification styles of Robot Framework (K1)
    • 1.4.1 Keyword-Driven Specification
      • LO-XX Understand the basic concepts of Keyword-Driven Specification (K2)
    • 1.4.2 Behavior-Driven Specification
      • LO-XX Understand the basic concepts of Behavior-Driven Specification (K2)
    • 1.4.3 Comparing Keyword-Driven and Behavior-Driven Specification
      • LO-XX Recall the differences between Keyword-Driven and Behavior-Driven Specification (K1)
    • 1.4.4 Data-Driven Specification
      • LO-XX Recall the purpose of Data-Driven Specification (K1)
  • 1.5 Organization and Licensing
    • 1.5.1 Open Source License
      • LO-XX Recall the type of open-source license under which Robot Framework is distributed (K1)
    • 1.5.2 About the Robot Framework Foundation
      • LO-XX List and recall the key objectives and organizational form of the Robot Framework Foundation (K1)
    • 1.5.3 Robot Framework Webpages
      • LO-XX Recall the official webpages for Robot Framework and its resources (K1)
• 2 Getting Started with Robot Framework
  • 2.1 Suite File & Tree Structure
    • LO-XX Understand which files and directories are considered suites and how they are structured in a suite tree. (K2)
    • 2.1.1 Suite Files
      • LO-XX Recall the conditions and requirements for a file to be considered a Suite file (K1)
    • 2.1.2 Sections and Their Artifacts
      • LO-XX Recall the available sections in a suite file and their purpose. (K1)
      • 2.1.2.1 *** Settings *** Section
        • LO-XX Recall the available settings in a suite file. (K1)
        • LO-XX Understand the concepts of suite settings and how to define them. (K2)
      • 2.1.2.2 *** Variables *** Section
        • LO-XX Recall the purpose of the *** Variables *** section. (K1)
      • 2.1.2.3 *** Test Cases or Tasks *** Section
        • LO-XX Understand the purpose of the *** Test Cases *** or *** Tasks *** section. (K2)
      • 2.1.2.4 *** Keywords *** Section
        • LO-XX Understand the purpose and limitations of the *** Keywords *** section. (K2)
      • 2.1.2.5 *** Comments *** Section
  • 2.2 Basic Suite File Syntax
    • LO-XX Understand the basic syntax of test cases and tasks. (K2)
    • 2.2.1 Separation and Indentation
      • LO-XX Understand and apply the mechanics of indentation and separation in Robot Framework. (K3)
    • 2.2.2 Line Breaks, Continuation and Empty Lines
      • LO-XX Be able to use line breaks and continuation in a statement. (K3)
    • 2.2.3 In-line Comments
      • LO-XX Be able to add in-line comments to suites. (K3)
    • 2.2.4 Escaping of Control Characters
      • LO-XX Understand how to escape control characters in Robot Framework. (K2)
    • 2.2.5 Example Suite File
      • LO-XX Understand the structure of a basic suite file. (K2)
  • 2.3 Executing Robot
    • LO-XX Recall the three components of the Robot Framework CLI. (K1)
    • 2.3.1 robot command & help
      • LO-XX Understand how to run the robot command and its basic usage. (K2)
    • 2.3.2 Execution Artifacts
      • LO-XX Explain the execution artifacts generated by Robot Framework. (K2)
    • 2.3.3 Status
      • LO-XX Recall the four different status labels used by Robot Framework. (K1)
      • 2.3.3.1 PASS
        • LO-XX Understand when an element is marked as PASS. (K2)
      • 2.3.3.2 FAIL
        • LO-XX Understand when an element is marked as FAIL. (K2)
    • 2.3.4 Logging possibilities (Log vs Console)
      • LO-XX Understand the difference between log messages and console output. (K2)
  • 2.4 Keyword Imports
    • 2.4.1 Libraries
      • LO-XX Recall the purpose of keyword libraries and how to import them. (K1)
      • LO-XX Recall the three types of libraries in Robot Framework. (K1)
    • 2.4.2 Resource Files
      • LO-XX Recall the purpose of resource files. (K1)
      • LO-XX Use resource files to import new keywords. (K3)
    • 2.4.3 Import Paths
      • LO-XX Understand the different types of paths that can be used to import libraries and resource files. (K2)
  • 2.5 Keyword Interface and Documentation
    • LO-XX Understand the structure of keyword interfaces and how to interpret keyword documentation. (K2)
    • 2.5.1 Documented Keyword Information
      • LO-XX Recall the information that can be found in a keyword documentation. (K1)
      • 2.5.1.1 Example Keyword in Library Documentation
    • 2.5.2 Keyword Arguments
      • LO-XX Understand the difference between argument kinds. (K2)
      • 2.5.2.1 Mandatory Arguments
        • LO-XX Understand the concept of mandatory arguments and how they are documented. (K2)
      • 2.5.2.2 Optional Arguments
        • LO-XX Understand the concept of optional arguments and how they are documented. (K2)
      • 2.5.2.3 Embedded Arguments
        • LO-XX Recall the concept of embedded arguments and how they are documented. (K1)
      • 2.5.2.4 Argument Types
        • LO-XX Understand the concept of argument types and automatic type conversion. (K2)
      • 2.5.2.5 Return Types
        • LO-XX Understand the concept of return type hints. (K2)
    • 2.5.3 Keyword Documentation & Examples
      • LO-XX Understand how to read keyword documentation and how to interpret the examples. (K2)
  • 2.6 Writing Test|Task and Calling Keywords
    • LO-XX Understand how to call imported keywords and how to structure keyword calls. (K2)
    • 2.6.1 Positional Arguments
      • LO-XX Understand the concept of how to set argument values positionally. (K2)
      • 2.6.1.1 Variable Number of Positional Arguments
        • LO-XX Recall how variable number of positional arguments are marked in the documentation and their use-case. (K1)
    • 2.6.2 Named Arguments
      • LO-XX Understand the concept of named arguments and how to set argument values by their name. (K2)
      • 2.6.2.1 Named-Only Arguments
        • LO-XX Recall named-only arguments and where they are located. (K1)
      • 2.6.2.2 Free Named Arguments
        • LO-XX Recall how free named arguments are marked in documentation. (K1)
    • 2.6.3 Embedded Arguments / Using Behavior-Driven Specification
      • LO-XX Recall how to use enbedded arguments. (K1)
• 3 Keyword Design, Variables, and Resource Files
  • 3.1 Resource File Structure
    • 3.1.1 Sections in Resource Files
  • 3.2 Variables
    • LO-XX Understand how variables in Robot Framework are used to store and manage data (K2)
    • LO-XX Recall the relevant five different ways to create and assign variables(K1)
    • 3.2.1 Variable Syntax and Access Types
      • LO-XX Recall the four syntactical access types to variables with their prefixes (K1)
      • LO-XX Recall the basic syntax of variables (K1)
    • 3.2.2 *** Variables *** Section
      • LO-XX Create variables in the Variables section (K3)
      • LO-XX Use the correct variable prefixes for assigning and accessing variables. (K3)
      • 3.2.2.1 Scalar Variable Definition
        • LO-XX Create and assign scalar variables (K3)
        • LO-XX Understand how multiple lines can be used to define scalar variables (K2)
      • 3.2.2.2 Primitive Data Types
        • LO-XX Understand how to access primitive data types (K2)
      • 3.2.2.3 List Variable Definition
        • LO-XX Understand how to set and access data in list variables (K2)
      • 3.2.2.4 Dictionary Variable Definition
        • LO-XX Understand how to set and access data in dict variables (K2)
    • 3.2.3 Return values from Keywords
      • LO-XX Be able to assign return values from keywords to variables (K3)
      • 3.2.3.1 Assigning to Scalar Variables
    • 3.2.4 VAR Statement
      • LO-XX Understand how to create variables using the VAR statement (K2)
    • 3.2.5 Variable Scope Introduction
      • LO-XX Understand how local and suite scope variables are created (K2)
  • 3.3 User Keyword Definition & Arguments
    • 3.3.1 *** Keywords *** Section
    • 3.3.2 User Keyword Names
      • LO-XX Recall the rules how keyword names are matched. (K1)
    • 3.3.3 User Keyword Settings
      • LO-XX Recall all available settings and their purpose for User Keywords (K1)
    • 3.3.4 User Keyword Documentation
      • LO-XX Recall the significance of the first logical line and in keyword documentation for the log file (K1).
    • 3.3.5 User Keyword Arguments
      • LO-XX Understand the purpose and syntax of the [Arguments] setting in User Keywords (K2).
      • 3.3.5.1 Defining Mandatory Arguments
        • LO-XX Recall what makes an argument mandatory in a user keyword. (K1)
        • LO-XX Define User Keywords with mandatory arguments. (K3)
      • 3.3.5.2 Defining Optional Arguments
        • LO-XX Recall how to define optional arguments in a user keyword. (K1)
        • LO-XX Define User Keywords with optional arguments. (K3)
      • 3.3.5.3 Embedded Arguments
        • LO-XX Describe how embedded arguments are replaced by actual values during keyword execution (K2).
        • LO-XX Understand the role of embedded arguments in Behavior-Driven Development (BDD) style. (K2)
      • 3.3.5.4 Other Argument Kinds
    • 3.3.6 RETURN Statement
      • LO-XX Understand how the RETURN statement passes data between different keywords. (K2)
      • LO-XX Use the RETURN statement to return values from a user keyword and assign it to a variable. (K3)
    • 3.3.7 Keyword Conventions
      • LO-XX Recall the naming conventions for user keywords (K1).
  • 3.4 Data-Driven Specification
    • LO-XX Understand the basic concept and syntax of Data-Driven Specification (K2)
    • 3.4.1 Test|Task Templates
      • LO-XX Understand how to define and use test|task templates (K2)
      • LO-XX Recall the differences between the two different approaches to define Data-Driven Specification (K1)
      • 3.4.1.1 Multiple Named Test|Task With One Template
        • LO-XX Recall the syntax and properties of multiple named test|task with one template (K1)
      • 3.4.1.2 Named Test|Task With Multiple Data Rows:
        • LO-XX Recall the syntax and properties of named test|task with multiple data rows (K1)
  • 3.5 Advanced Importing of Keywords and Naming Conflicts
    • LO-XX Recall that naming conflicts can arise from the import of multiple resource files (K1).
    • 3.5.1 Importing Hierarchies
      • LO-XX Understand how recursive imports of resource files and libraries work (K2).
    • 3.5.2 Library Configuration
      • LO-XX Recall the purpose of the Importing section in library documentation (K1).
      • LO-XX Be able to configure a library import using arguments (K3).
    • 3.5.3 Naming Conflicts
      • LO-XX Explain how naming conflicts can happen and how to mitigate them (K2).
• 4 Advanced Structuring and Execution
  • 4.1 Setups (Suite, Test|Task, Keyword)
    • LO-XX Recall the purpose and benefits of Setups in Robot Framework (K1)
    • LO-XX Understand the different levels where and how a Setup can be defined (K2)
    • 4.1.1 Suite Setup
      • LO-XX Recall key characteristics, benefits, and syntax of Suite Setup (K1)
      • LO-XX Understand when Suite Setup is executed and used (K2)
    • 4.1.2 Test|Task Setup
      • LO-XX Recall key characteristics, benefits, and syntax of Test Setup (K1)
      • LO-XX Understand when Test|Task Setup is executed and used (K2)
    • 4.1.3 Keyword Setup
      • LO-XX Recall key characteristics and syntax of Keyword Setup (K1)
  • 4.2 Teardowns (Suite, Test|Task, Keyword)
    • LO-XX Understand the different levels where and how a Teardowns can be defined and when they are executed (K2)
    • LO-XX Recall the typical use cases for using a Teardowns (K1)
    • 4.2.1 Suite Teardown
      • LO-XX Recall key characteristics, benefits, and syntax of Suite Teardown (K1)
      • LO-XX Understand when Suite Teardown is executed and used (K2)
    • 4.2.2 Test|Task Teardown
      • LO-XX Recall key characteristics, benefits, and syntax of Test|Task Teardown (K1)
      • LO-XX Understand when Test|Task Teardown is executed and used (K2)
    • 4.2.3 Keyword Teardown
      • LO-XX Recall key characteristics, benefits, and syntax of Keyword Teardown (K1)
  • 4.3 Initialization Files
    • 4.3.1 Purpose of Initialization Files
      • LO-XX Recall the purpose and possibilities of Initialization Files (K1)
    • 4.3.2 Suite Setup and Suite Teardown of Initialization Files
      • LO-XX Understand the execution order of Suite Setup and Suite Teardown in Initialization Files and their sub-suites and tests|tasks (K2)
    • 4.3.3 Allowed Sections in Initialization Files
      • LO-XX Recall the allowed sections and their content in Initialization Files (K1)
    • 4.3.4 Example of an Initialization File
  • 4.4 Test|Task Tags and Filtering Execution
    • LO-XX Recall the purpose of Test|Task Tags in Robot Framework (K1)
    • 4.4.1 Assigning Tags to Tests|Tasks
      • LO-XX Recall the syntax and different ways to assign tags to tests|tasks (K1)
    • 4.4.2 Using Tags to Filter Execution
      • LO-XX Understand how to filter tests|tasks using the command-line interface of Robot Framework (K2)
      • 4.4.2.1 Including Tests|Tasks by Tags
      • 4.4.2.2 Excluding Tests|Tasks by Tags
      • 4.4.2.3 Combining Include and Exclude Options
      • 4.4.2.4 Using Tag Patterns
    • 4.4.3 Reserved Tags
  • 4.5 SKIP Test|Task Status
    • LO-XX Recall the use-case and purpose of skipping tests|tasks in Robot Framework (K1)
    • LO-XX Recall the different ways to skip tests|tasks in Robot Framework (K1)
    • 4.5.1 Skipping By Tags Selection (CLI)
      • LO-XX Recall the differences between skip and exclude (K1)
    • 4.5.2 Skipping Dynamically During Execution
    • 4.5.3 Automatically Skipping Failed Tests
• 5 Exploring Advanced Constructs
  • 5.1 Advanced Variables
    • 5.1.1 Variable Priorities
      • LO-XX Understand the difference between statically defined and dynamically created variables in Robot Framework (K2)
      • 5.1.1.1 Statically Defined or Imported Variables
        • LO-XX Recall the priority of statically defined or imported variables in Robot Framework (K1)
      • 5.1.1.2 Dynamically Created Variables
        • LO-XX Recall the priority of dynamically created variables in Robot Framework (K1)
    • 5.1.2 Variable Scopes
      • LO-XX Recall the different variable scopes in Robot Framework (K1)
      • 5.1.2.1 . Global Scope
        • LO-XX Recall how to define global variables and where they can be accessed (K1)
      • 5.1.2.2 . Suite Scope
        • LO-XX Recall how to define suite variables and where they can be accessed (K1)
      • 5.1.2.3 . Test|Task Scope
        • LO-XX Recall how to define test|task variables and where they can be accessed (K1)
      • 5.1.2.4 . Local Scope
        • LO-XX Recall how to define local variables and where they can be accessed (K1)
    • 5.1.3 Global Variables via Command Line
    • 5.1.4 List-Variables (Advanced)
      • 5.1.4.1 Assigning List Variables
        • LO-XX Recall that assignments to @{list} variables convert values to lists automatically (K1)
      • 5.1.4.2 Accessing List Variables
        • LO-XX Recall that @{list} unpacks the values of a list variable when accessed (K1)
    • 5.1.5 Dict-Like
      • 5.1.5.1 Assigning Dictionary Variables
        • LO-XX Recall that assignments to &{dict} variables automatically convert values to Robot Framework Dictionaries and enable dot-access (K1)
      • 5.1.5.2 Accessing Dictionary Variables
        • LO-XX Recall that &{dict} unpacks to multiple key=value pairs when accessed (K1)
    • 5.1.6 Built-In Variables
      • LO-XX Recall that Robot Framework provides access to execution information via Built-In variables (K1)
  • 5.2 Control Structures
    • 5.2.1 IF Statements
      • LO-XX Understand the purpose and basic concept of IF-Statements (K2)
      • 5.2.1.1 Basic IF Syntax
    • 5.2.2 IF/ELSE IF/ELSE Structure
    • 5.2.3 Inline IF Statement
    • 5.2.4 FOR Loops
      • LO-XX Understand the purpose and basic concept of FOR Loops (K2)
      • 5.2.4.1 Basic FOR Loop Syntax
    • 5.2.5 WHILE Loops
      • LO-XX Understand the purpose and basic concept of WHILE Loops (K2)
    • 5.2.6 BREAK and CONTINUE
      • LO-XX Understand the purpose and basic concept of the BREAK and CONTINUE statements (K2)