Robot Framework Interview Questions

Are you getting ready for a Robot Framework interview? This in-depth guide will assist you in preparing for some of the most frequently asked Robot Framework interview questions, from beginner to advanced techniques. If you are a QA engineer, automation tester, or DevOps professional, these select questions will prepare you for basic syntax, variable use, testing with Selenium or Appium, and CI/CD pipeline testing.

One of the most widely used tools for test automation and RPA (robotic process automation) is the Robot Framework, which is based on keyword-driven techniques, a simplified syntax for humans, and seamless integration with Python, Java, Selenium, and Jenkins.

Learning these 60 questions and their specified answers will not only develop your technical knowledge but will also provide the confidence to tackle real-world automated test scenarios and nail your next Robot Framework interview.

Beginner Robot Framework Interview Questions

If you are just starting out with Robot Framework, these beginner-level interview questions will introduce you to the framework’s key ideas, such as its basic syntax, libraries, and core features. This is suitable for both freshers and QA engineers who want to explore the fundamentals of working in automation testing.

1. What is Robot Framework?

The Robot Framework is an open-source, keyword-driven automation framework that’s commonly used for acceptance testing and Robotic Process Automation.

It is implemented in Python, and you can add your own libraries to enhance functionality. Popular libraries include Selenium, Appium, and Database libraries.

2. What are the advantages of test automation using the Robot Framework?

There are many pros to using the Robot Framework, including:

• Human-readable and maintainable tests: Since the syntax is keyword-based, non-developers can read and modify tests. 
• Reusability: You can reuse the keywords across test cases or suites.
• Extensibility: You can add third-party and custom libraries to extend functionality in the test framework.
• Built-in reports and logs: You can generate reports and have an easy-to-read log all in HTML format.
• Integration capabilities: You can use it with programs like Selenium WebDriver, Appium, and Jenkins etc.
• Cross-platform: It can operate in multiple OS environments.

The Robot Framework is a very suitable framework for teams practicing behavior-driven development and/or acceptance testing.

3. What are the features of the Robot Framework? Some of its key features include:

• You can use a keyword-driven approach, which allows for modular and reusable test design.
• Robot Framework has a simple tabular-style syntax that allows for presenting a readable test case structure in either plain text or .robot format for the individual using the framework.
• You can output to multiple formats, including .robot, .txt, .tsv, or .html.
• It supports extensibility to external libraries (you can use libraries, such as SeleniumLibrary, DatabaseLibrary, and AppiumLibrary for example).
• It has a command-line interface (CLI) that allows you to execute tests and you can generate a report via the command line terminal.
• It has built-in automatic reporting after test execution, you will receive log.html, report.html and output.xml files based on your business rules.
• It allows cross-language implementation. You can generally call keywords via a library that is implemented, for example in Python, Java, or .NET.

4. What are the disadvantages of using the Robot Framework?

While the framework has several positive attributes, here are some disadvantages:

• Slower execution time relative to pure-code frameworks like PyTest and unittest, particularly for more extensive test suites.
• It is not beginner-friendly when it comes to more advanced customization cases (e.g., requiring dynamic test data, conditional, or looping logic).
• Lacks sophisticated debugging tools, as debugging a failure can be difficult to the abstraction of keywords in the framework.
• Performance may be impacted when running extensive tests with relatively high-volume test data.
• Requires additional libraries for certain features (e.g. UI Automation, you would need Selenium for web applications or Appium for mobile applications).

5. What programming languages can you use to write test cases in Robot Framework?

Robot Framework uses a keyword-driven approach, so test cases are written in plain text using keywords rather than a specific programming language.

However, to extend its functionality or create custom libraries, you can use Python or Java.

In short:

• Test cases are written in plain English syntax using .robot or .txt files.
• Custom libraries can be developed in Python or Java and then imported into your test cases.

So, while you don’t directly code test cases in Python or Java, the framework is highly extensible through them.

6. What are the different types of test libraries in Robot Framework?

Test libraries in Robot Framework provide the implementation behind keywords. There are three main types:

1. Standard Libraries – Built into Robot Framework.
   Examples:
   • BuiltIn
   • OperatingSystem
   • Collections
   • DateTime
   • String
2. External Libraries – Created and maintained by the community or third parties.
   Examples:
   • SeleniumLibrary (for web testing)
   • AppiumLibrary (for mobile testing)
   • DatabaseLibrary (for database testing)
3. Custom Libraries – User-defined libraries created in Python or Java when existing ones don’t meet specific needs.

You can combine standard, external, and custom libraries in a single project depending on your testing requirements.

7. What are the different types of variables in Robot Framework?

Robot Framework supports four main types of variables, each with distinct syntax and use:

• Scalar variables (${ }) – Store a single value.
  Example: ${username} = Ayaan

• List variables (@{ }) – Hold multiple values, similar to arrays.
  Example: @{fruits} = Apple Banana Mango

• Dictionary variables (&{ }) – Store key-value pairs.
  Example: &{user} = name=Ayaan role=Tester

• Environment variables – Retrieved from the system environment.
  Example: ${ENV:PATH}

These variable types make data handling more organized and help keep test cases clear and maintainable.

8. What are the names of all the file formats that the Robot Framework supports?

Robot Framework supports several file types for writing test cases and resource files. The most common are:

• .robot – Standard extension for test suites.
• .txt – Plain text files using the same tabular syntax.
• .tsv – Tab-separated value files, useful for spreadsheet-like data.
• .resource – Store reusable keywords and variables that can be imported.

Earlier versions supported .html files, but that format is now deprecated. In current practice, you will mainly use .robot, .txt, and .resource files.

9. What do you understand by RIDE in the context of the Robot Framework?

RIDE stands for Robot Framework Integrated Development Environment. It is a graphical editor that helps testers create, manage, and execute test cases without relying solely on a text editor or command line.

Key features include:

• Syntax highlighting for keywords and variables
• Easy creation of test suites, test cases, and resource files
• Ability to run tests directly from the interface
• Keyword and setting auto-completion

In short, RIDE provides a user-friendly interface for Robot Framework, making it ideal for testers who prefer a visual environment over manual scripting.

10. What is the name of the dependency that you must need in order to install and use the RIDE editor in the context of the Robot Framework?

To install and use RIDE, you must install a library called wxPython first.

RIDE is built on wxPython, which provides all of the graphical components discussed in the library.

Here’s an example command to install wxPython first and then RIDE:

pip install wxPython

pip install robotframework-ride

To avoid installation errors, ensure you install a compatible wxPython with the Python version installed on the machine.

11. What is the syntax for creating a test case in Robot Framework?

The test case in Robot Framework is written in a tabular format and uses sections surrounded by three asterisks (***). The syntax is simple and easily readable.

Here’s a small example:

*** Settings ***

Library    SeleniumLibrary


*** Variables ***

${URL}     https://example.com


*** Test Cases ***

Open Example Website

    Open Browser    ${URL}    chrome

    Title Should Be    Example Domain

    Close Browser

Explanation:

• The *** Settings *** section denotes dependencies like libraries or resource files.
•  The *** Variables *** section contains reusable data.
•  The *** Test Cases *** section is where you define the actual logic of the test, using keywords.

The indentation (typically two or more spaces) separates keywords from their arguments.

12. How do you use variables in Robot Framework? Provide an example.

Variables in Robot Framework allow for reusability and maintainability of test cases. Variables can hold values (such as URLs, credentials, and expected results) that can be used across all of your test cases.

For example:

*** Variables ***

${URL}       https://example.com

${BROWSER}   chrome

${USERNAME}  test_user


*** Test Cases ***

Login Test

    Open Browser    ${URL}    ${BROWSER}

    Input Text      id:username    ${USERNAME}

    Click Button    id:login

    Close Browser

Here, if the URL or the browser were to change, you would be able to change the variable one time, and the change would be reflected in all of your test cases. 

One of the best benefits of using variables in Robot Framework is that it reduces maintenance as your collection of test cases grows.

13. What is the purpose of the *** Settings *** section in a Robot Framework test suite?

 The ***Settings*** section is likened to the configuration area of your test suite, because it defines what external libraries, resource files, metadata, etc., are to be used in conjunction with your test cases. 

It is like the area of your test suite’s infrastructure setup prior to running your actual tests.

Here’s an example:

*** Settings ***

Library    SeleniumLibrary

Resource   common_keywords.resource

Suite Setup    Open Browser To Login Page

Suite Teardown    Close All Browsers

Explanation:

• Library – imports an external library such as SeleniumLibrary. 
• Resource – imports reusable keywords and variables from another file.
• Suite Setup and Suite Teardown – where actions are defined to run before or after every test in the suite.

So that essentially, the Settings section tells Robot Framework how to prepare for execution, prior to actually executing your tests.

14. What is the purpose of the *** Test Cases *** section?

This is the most used part of your test suite, where you define your tests in the first place. Each test case that you write will use keywords, which can come from built-in libraries, external libraries or user libraries.

Example:

*** Test Cases ***

Verify Login Functionality

    Open Browser    https://example.com    chrome

    Input Text      id:username    test_user

    Input Text      id:password    test_pass

    Click Button    id:login

    Page Should Contain    Welcome

    Close Browser

Under every test case, each line is a keyword and some arguments.  The structure of keywords and arguments is supposed to be easy to read for non-programmers, and It is common to the keyword-driven testing idea of Robot Framework.

15. What is the purpose of the *** Keywords *** section?

 The *** Keywords *** section is where you define custom or user-defined keywords, which are like reusable mini-scripts or functions (that can be called inside test cases).

For instance:

*** Keywords ***

Login To Application

    Input Text    id:username    ${USERNAME}

    Input Text    id:password    ${PASSWORD}

    Click Button  id:login

So in your test case you could simple have:

*** Test Cases ***

Verify User Login

    Login To Application

Defining keywords separately from test cases helps with readability, avoids repetition, and makes for easier maintenance. It also helps to promote modular design – and that’s something interviewers love to hear the prospect of in test architecture.

16. How do you install Robot Framework?

The installation of Robot Framework is simple given that it is based off python. You will need Python and pip (the python package manager) installed on your computer. 

You can install it by:

pip install robotframework

You can verify your installation by checking the version:

robot --version

If you plan to test the web using SeleniumLibrary, you will want to install that as well:

pip install robotframework-seleniumlibrary

In addition to Robot Framework, some testers will install RIDE for IDE support, or use editors like VS Code with Robot Framework extensions installed.

17. What are standard libraries in the Robot Framework? Name the standard libraries.

Standard libraries in Robot Framework are libraries built into Robot Framework itself. Standard libraries provide a variety of ready-to-use keywords for common testing needs: that means you do not have to install third-party libraries all the time.

Some common standard libraries include:

• BuiltIn – provides many standard libraries that are available, i.e., Log, Should Be Equal, etc.
• Collections – for handling lists and dictionaries.
• DateTime – concerned with handling date and time information.
• OperatingSystem – runs operating system commands and works with files.
• String – works with string values.
• Dialogs – displays dialog boxes while running the tests.
• Screenshot – takes screenshots when running the test.
• XML – to work with XML files and data.

There are over a dozen standard libraries, and they provide most Robot Framework test suites with their foundation.

18. What is the use of Robot Framework?

Robot Framework is primarily a test automation framework and a robotic process automation (RPA) framework. It is well-suited for teams that want to write tests in a format that is human-readable and does not require extensive programming experience because of its keyword-driven approach.

Common use cases include:

• Acceptance testing – Confirming end-to-end functionality prior to release.
• Regression testing – Checking that no changes in the code have broken existing functionality.
• UI automation – Using Selenium or Appium libraries.
• API testing – Using the RequestsLibrary or others.
• Data-driven testing – Running the same test logic with several data sets.

In short, Robot Framework is an adaptable automation framework that is frequently used across web, mobile, database, and API testing scenarios.

19. What are environment variables in the context of the Robot Framework?

Environment variables in Robot Framework are variables that come directly from your operating system’s environment. You might use environment variables when you want to provide some dynamic information, such as file paths, credentials, or other configurations in your tests without hardcoding them.

You can access environment variables in Robot Framework by using the following syntax:

${ENV:VARIABLE_NAME}

For example:

Log To Console    ${ENV:PATH}

You can create your own environment variables before running your tests.

export BASE_URL=https://example.com

robot testsuite.robot

Inside the test, you can then use ${ENV:BASE_URL}.

This allows your tests to be portable and easier to execute in different environments, such as staging, QA, or production.

20. Who came up with the Robot Framework?

Robot Framework was invented around 2005 at Nokia Networks (now Nokia Solutions and Networks) by Pekka Klärck. It was originally developed as an internal tool for acceptance test automation and was open-sourced and licensed under Apache 2.0.

The Robot Framework started to develop as a community-driven framework, with contributions by companies and individual users from around the world.

Today, Robot Framework is maintained and managed by the Robot Framework Foundation, which provides ongoing development and open governance.

Intermediate Robot Framework Interview Questions

These intermediate level Robot Framework interview questions will take you beyond the basics. It dives into even more considerations for real-world testing scenarios, architectural considerations, reusable keywords, templates, tagging, and test execution strategies. Your skillset will prepare you for mid-level automation testing roles.

21. Explain the overall architecture of Robot Framework.

Robot Framework architecture is modular and layered, which aims to provide a flexible and extensible architecture.

At a high level, it comprises three layers:

1. Test Data Layer – This layer defines all the specifications of your test cases, settings, and keywords. The test data is stored in .robot or .txt files.
   It includes sections like:
   • *** Settings ***
   • *** Variables ***
   • *** Test Cases ***
   • *** Keywords ***
2. Test Execution Layer – This layer includes the Test Runner, which will read the test data and then execute the test cases along with the libraries. It manages everything that happens during the test execution.
3. Library and API Layer – This layer is responsible for any action taken by the libraries, either one of the existing external libraries (Selenium, Appium, or your own) or a custom library, alongside managing communication with any external tools like databases, browsers, APIs, etc.

Finally, Robot Framework will generate output files like XML, HTML, and an output log after execution.

Bottom line, Robot Framework architecture encourages separating the logic of the test implementation. This allows for easy scaling and maintenance in the testing environment.

22. Explain the high-level architecture of the Robot Framework.

 At a high level, you can think of the architecture like this:

Test Data → Test Runner → Libraries → System Under Test (SUT)

Here’s how it works:

1. The test data (written in .robot or .txt files) defines what needs to be tested.
2. The Test Runner reads this data, interprets the keywords, and executes them.
3. The Libraries (standard, external, or custom) implement these keywords and interact with the actual System Under Test : be it a web app, mobile app, or API.
4. Once execution finishes, the reporting engine generates output.xml, log.html, and report.html files.

So, the flow is essentially data → execution → reporting, with clear separation between what you test and how you test it.

23. How does Robot Framework integrate with external test libraries?

Robot Framework incorporates external libraries through its modular plugin architecture. You will declare the library in the ***Settings*** section and Robot will load it automatically during execution.

Example:

*** Settings ***

Library    SeleniumLibrary

Library    DatabaseLibrary

In the background when you run your test suite, Robot Framework will: 

1. Load the libraries you specified.  
2. Map their functions (for example Open Browser, Execute SQL, etc) to the corresponding keywords in Robot. 
3. Execute the keywords as part of the test flow.
   

The best thing is that you can write libraries in either Python or Java, and Robot will use introspection to dynamically expose their functions as keywords. 

This model will make Robot Framework extremely easy to extend: you can integrate your existing libraries or even third-party automation tools.

24. What role do resource files play in Robot Framework’s architecture?

Resource files in Robot Framework are shared modules that contain reusable components: typically keywords, variables, and settings.  They provide a mechanism for you to remove duplication and keep your test suites clean and modular.

For example, you can create a file called common.resource:

*** Variables *** 

${URL}    https://example.com

 *** Keywords *** 

Open Application    

      Open Browser    ${URL}    chrome

In your test suite, you can then import it:

*** Settings ***

 Resource    common.resource

Now you can use Open Application directly inside any test case.

Therefore, resource files promote re-use, organization, and collaboration, especially in a larger test automation project when multiple teams are working on different modules.

25. What is the purpose of the Test Runner in Robot Framework?

The Test Runner is, in fact, the center of Robot Framework. Its responsibility is to read the test data, interpret the keywords, run the tests, and generate reports.

If you run a command like:

robot testsuite.robot

Then the Test Runner performs the following:

1. Parse the test data from your .robot files.
2.  Initialize the environment (variables, libraries, resource files, etc.).
3.  Execute the test case(s) one at a time and according to any setup/teardown instructions.
4.  Generate the output files: output.xml, report.html, and log.html.

You can think of the Test Runner as a kind of conductor welding all the pieces together: data, libraries, keywords, and results, into one automated process.

26. How does Robot Framework handle reporting and logging?

Reporting and logging are strengths of Robot Framework. After a test has run, Robot Framework automatically creates three prominent files:

1. output.xml – A raw XML file of all execution results in detail.
2. report.html – A summarizing report of the number of test cases that passed and failed, run-time, and status.
3. log.html – A log of execution in detail, step by step, highlighting keyword execution during the test run while currently capturing screenshots if you have your test generating screenshots, as well as an error trace.

You also have the ability to set your own log level using the built-in key word like:

Log    This is a message

Log To Console    Execution started

You can also set your own log levels of DEBUG, INFO, WARN, or ERROR

So if you were to be asked in an interview, it would be an advantage to mention that the Robot’s built-in reporting system limits your organization’s dependencies on others to see their test results quickly.

27. What is the role of listeners in Robot Framework architecture?

In Robot Framework, listeners are extensions that allow you to augment or modify the behavior of test action execution. Listeners are similar to event handlers in that they respond to specific events that happen during an execution (e.g., A test either started, failed, or completed).

You can register a listener when you execute your tests like so:

robot --listener MyListener.py testsuite.robot

You can write a listener file (for example, MyListener.py) using the Python programming language, which will typically contain the following methods:

def start_test(name, attributes):

    print(f"Starting test: {name}")

def end_test(name, attributes):

    print(f"Ending test: {name} with status: {attributes['status']}")

Listeners are also very useful anytime you want to do one of the following:

• Integrate Robot Framework with external tools (e.g. JIRA, Slack, custom dashboards).
• Log or capture metrics that are additional to what Robot Framework logs
• Change the report’s format or behavior on the fly.

In summary, listeners give you increased control of what happens before, during, and after the test result execution.

28. How do you create custom keywords in Robot Framework?

You can create custom keywords in Robot Framework in two ways:

1. Directly, within the test suite using the  *** Keywords *** section:
   
   

   *** Keywords ***
   
   Login To Application
   
       Input Text    id:username    ${USERNAME}
   
       Input Text    id:password    ${PASSWORD}
   
       Click Button  id:login

2. or, by writing a custom Python library: You can create a Python class and expose its methods as Robot keywords.
   
   

   from robot.api.deco import keyword
   class MyLibrary:
   
       @keyword
   
       def greet_user(self, name):
   
           print(f"Hello, {name}!")

Then import it into your .robot file:

*** Settings ***

Library    MyLibrary.py

*** Test Cases ***

Test Greeting

    Greet User    Ayaan

The second option is recommended when your project gets beyond very simple testing, or when sharing keywords is valuable across many teams, or many projects.

29. How do you create reusable test case templates in Robot Framework?

 Reusable test case templates in Robot Framework mean discovering a common keyword structure that multiple test cases can follow, just with different data.

You create that template using Test Template, and each of your test cases would use that same keyword as its base functionality.

An example can be seen here:

*** Settings ***

Test Template    Validate Login

*** Test Cases ***

Valid User Login

    valid_user    valid_pass

Invalid User Login

    invalid_user    invalid_pass

*** Keywords ***

Validate Login

    [Arguments]    ${username}    ${password}

    Open Browser    https://example.com    chrome

    Input Text    id:username    ${username}

    Input Text    id:password    ${password}

    Click Button    id:login

    Close Browser

In the *** Test Cases *** section, each of your test cases will call the same keyword (Validate Login) with different sets of arguments.  This is also very useful for data-driven testing as it removes duplication but still keeps it readable.

30. Explain the concept of test templates in Robot Framework.

A test template is basically a keyword-driven structure that defines the logic for multiple test cases that share the same steps, just different data. You can think of it just like a function or method in programming: define the logic once and call it with different arguments.

Key points:

• Defined in the *** Settings ****** section with the following:
  

   Test Template <keyword name>

• Each test case below has arguments for that keyword.
• Good for data-driven or parameterized tests.
  

Example:

*** Settings ***

Test Template    Add Two Numbers

*** Test Cases ***

Addition of 2 and 3

    2    3    5

Addition of 5 and 10

    5    10    15

*** Keywords ***

Add Two Numbers

    [Arguments]    ${a}    ${b}    ${expected}

    ${result}=    Evaluate    ${a} + ${b}

    Should Be Equal As Numbers    ${result}    ${expected}

Instead of writing repetitive test cases, it helps you re-use the logic efficiently, just changing the input data.

31. What are tags in Robot Framework and how are they used?

Tags in Robot Framework are similar to labels you can apply to test cases. Tags are used to organize/group/and to run only the tests you want to run.

You could add tags in an equal number of ways:

In the *** Test Cases *** section directly:

*** Test Cases ***

Login Test

    [Tags]    smoke    login

    Open Browser    https://example.com    chrome

Or globally in the *** Settings *** section using:

 *** Settings ***

Force Tags    regression

How do they help?

1. You can run specific group(s) of tests:
   

    robot --include smoke tests/

2. or exclude certain tests::
   

    robot --exclude slow tests/

They are also used to filter CI/CD, reports, and for prioritizing tests.

Overall, tags help you to manage large test suites because you have fine control over which tests you want to run and when.

32. How do you create a data-driven test case in Robot Framework?

A data-driven test in Robot Framework is when the same test logic runs multiple times, with different data inputs. There is more than one way to accomplish this in Robot Framework, but the most common are:

1. Using Test Templates (see above):

 *** Settings ***

Test Template    Validate Credentials

*** Test Cases ***

Valid Login

    user1    pass1

Invalid Login

    user2    wrongpass

2. Using external data files: for example, reading from Excel, CSV or JSON files using libraries like:

• DataDriver
• ExcelLibrary
• OperatingSystem with file reading keywords.

Example with the DataDriver library:

pip install robotframework-datadriver

*** Settings ***

Library    DataDriver    file=logindata.csv

Test Template    Validate Login

This puts a different spin on data-driven tests as it allows you to manage large amounts of test data, separately from your .robot files.

In other words, data-driven tests in Robot Framework is just breaking (decoupling) the test logic from the test data, therefore, making your tests more flexible and scalable.

33. How do you handle setup and teardown in Robot Framework?

The setup and teardown modules of Robot Framework enable you to define actions to be performed before and after a test case, test suite, or keyword is executed. This helps make sure that your testing environment is correct and cleaned after testing.

You can define them at different levels:

1. Test Case Level (within the test itself):
   

   *** Test Cases ***
   
   Verify Login
   
       [Setup]    Open Browser    https://example.com    chrome
   
       Input Text    id:username    test_user
   
       [Teardown]    Close Browser

2. Level (in the *** Settings *** section):
   

   *** Settings ***
   
   Suite Setup       Open Application
   
   Suite Teardown    Close Application

3. Keyword Level (for more complex reusable flows):
   

   *** Keywords ***
   
   Prepare Environment
   
       [Setup]    Start Server
   
       [Teardown]    Stop Server

In short, a setup creates your testing environment, and a teardown makes sure that your testing environment is cleaned regardless of whether the test passes or fails.

34. What is Setup and TearDown in Robot Framework?

 
Setup and TearDown are keywords in Robot Framework that allow you to define actions to run automatically before and after a test or suite executes, respectively.

Think of it like this:

• Setup → Pre-test configuration (e.g., opening a browser, logging into the app).
• Teardown → Post-test cleanup (e.g., closing browsers, deleting test data, logging out).

Example:

*** Settings ***

Test Setup       Open Browser To Login Page

Test Teardown    Close Browser

Setup and teardown help to keep the tests isolation: Making sure each test starts in a clean state without affecting the next one. This is especially useful for end-to-end testing scenarios and UI automation when leftover state can potentially cause the testing to fail.

35. How do you execute a test case in Robot Framework?

You run a test case with the robot command from a terminal or command line.

For example:

robot testsuite.robot

This command will:

• Parse the test file (testsuite.robot)
• Run all the test cases inside it
• Generate output files (output.xml, report.html, log.html)

You also have options to:

1. Run tests in the correct directory:

robot tests/

2. Set a variable from the command line:

robot --variable BROWSER:chrome testsuite.robot

3. Change the output directory:

robot --outputdir results/ testsuite.robot

So, the robot command line interface (CLI) command is really the primary way to trigger test actions and control runtime configurations.

36. How do you execute a specific test suite in Robot Framework?

In Robot Framework, a test suite usually means a .robot file or a folder containing more than one test file.

To run a test suite, you just point the robot command to the file or directory.

Example:

robot tests/login_tests.robot

Or, if you have the tests in folders:

robot tests/smoke/

You can also filter by suite name:

robot --suite "Smoke Tests" tests/

If you have nested test suites, Robot Framework will run every test case under that suite hierarchy. This is a nice feature when you want to run a subset of tests or test suites on a given module or feature, without having to run the entire test repository.

37. How do you run only a specific test case in Robot Framework?

To run a specific test case, we will use the –test option (or -t flag) as follows when issuing a robot command.

We must use the exact test case name as used in the .robot file, as below:

For example:

robot --test "Valid Login Test" testsuite.robot

If you have multiple tests using similar names, we can also use pattern matching: 

robot --test "*Login*" testsuite.robot

If we combine that with specific output directories:

robot --test "Search Functionality" --outputdir results/ testsuite.robot

This feature is very useful for debugging tests, so you can run a specific (failing) test rather than the entire suite.

38. How do you skip or tag test cases in Robot Framework?

Robot Framework does not have a direct “skip” keyword as some other frameworks do, but we can control test execution with tags and run-time filters. 

You can tag tests that you wish to not run:

*** Test Cases ***

Feature Under Development

    [Tags]    skip

    Log    This test will be skipped for now.

Then, when you run the test, you can use:

robot --exclude skip tests/

Or if you choose to add a tag for skip (from newer versions of Robot Framework 6.0+):

*** Test Cases ***

Skip This Test

    Skip    This test is temporarily skipped.

Tags are also a very powerful way to organize tests: 

You can include certain tags:

robot --include smoke tests/

And exclude certain tags:

robot --exclude regression tests/

So, combining tagging with skip logic ultimately gives you better control of what runs and what does not run in your test suite.

39. How do you control the test execution order in Robot Framework?

 By default, Robot Framework executes tests in the sequence they were defined in the test suite. There are a couple of ways to affect Test Execution Ordering below:

• Manual ordering: All you need to do is define the tests in your desired order in the .robot file. Robot framework will then run them in order from top to bottom.
• Tag-based execution: If you have a batch of tests that you want to run in a specific order, you can use tags to do so to run them in their desired order.
  
  

  robot --include smoke tests/
  robot --include regression tests/

• Suite-level setup and teardown: This is useful for dictating flow when tests depend on common initialization in other suites.
• Custom test runners or listeners: For more advanced situations, you could implement logic in the listener to reorder the tests programmatically before execution.
  

In general, we recommend keeping tests as independent as possible and utilizing tags or test organization instead of enforcing test execution ordering however, you want to make sure you maintain references to other tests when they are dependent on tests from other suites or test cases. By relying on tags or tests, organizational methods will be better maintainable and will be easier to maintain when tests run in parallel.

40. How do you generate a test report in Robot Framework?

 After every test run, Robot Framework automatically creates a report and log for you: there’s nothing you need to configure.

When you run:

robot testsuite.robot

You will end up with:

• output.xml – the raw result data
• report.html – a summary report (pass/fail counts, durations)
• log.html – a detailed log of your step-by-step execution

If you want to control where these files go, use:

robot --outputdir reports/ testsuite.robot

You can also rename them:

robot --report MyReport.html --log MyLog.html testsuite.robot

These HTML reports are interactive, which means you can click on the test cases to see the logs, variables, screenshots, failures, etc. This can make the debugging and analysis of results easier.

Advanced Robot Framework Interview Questions

These advanced Robot Framework interview questions will explore some of the most impactful topics, such as integrations with Selenium and Appium, CI/CD pipelines, API testing, parallel running tests, dynamic tests, custom libraries, and large-scale automation design implications. This is suitable for senior quality engineers, SDETs, and Test Architects who are looking for interviews for expert-level positions.

41. How do you integrate Robot Framework with Selenium WebDriver?

Robot Framework does not have direct communication with the browsers, it relies on the external library SeleniumLibrary to wrap Selenium WebDriver.

Steps:

1. Install both packages

pip install robotframework-seleniumlibrary selenium

2. Import the library to your test suite

*** Settings ***

Library    SeleniumLibrary

3. Define/develop your tests using the (Robot Framework’s) keywords provided

*** Test Cases ***

4. Verify Page Title

    Open Browser    https://example.com    chrome

    Title Should Be    Example Domain

    Close Browser

SeleniumLibrary will call the WebDriver methods in the background, allowing you to use readable Robot keywords to perform anything available via the Selenium API, which includes handling alerts, iFrames, waits, and so forth.

42. How do you integrate Robot Framework with Jenkins?

• Linking to Jenkins is a typical setup for continuous testing.
• Create a Freestyle or Pipeline Jenkins job. 
• Be sure you have Python + Robot Framework installed on the build node.
• Add a build step that looks like the following:

 robot --outputdir results tests/

Post-build, publish results. You may choose to set up:

• • Robot Framework Plugin for Jenkins – “presents raw log and HTML reports nicely”
  • or archive the HTML reports manually.
    

In a Pipeline script:

stage('Run Tests') {

    steps {

        sh 'robot --outputdir results tests/'

    }

}

stage('Publish Results') {

    steps {

        robot archiveDir:  aresults'

    }

}

This will run your automated tests on every commit, and Jenkins will output the results for you.

43. How do you integrate Robot Framework with JIRA?

 While there is no built-in connector for JIRA, integration is carried out through APIs, plugins, or listeners.

Some more common methods of integration would be:

1. Using the robotframework-jira-library:

pip install robotframework-jira

 *** Settings ***

Library    JiraLibrary    https://your-jira-instance    ${USERNAME}    ${PASSWORD}

2. After that, you can create or update issues using keywords such as

Create Issue or Add Comment To Issue.

Alternatively, you can develop a custom listener or write a Python script to post a JSON payload to JIRA’s REST API to create a bug ticket on test failure.

Either way, now you are connecting the test outcome back to project tracking for traceability and automatic defect logging.

44. How do you integrate Robot Framework with REST APIs?

 
The library you would use for API testing is the RequestsLibrary, wrapping Python’s requests module.

Setup:

pip install robotframework-requests

Usage:

*** Settings ***

Library    RequestsLibrary

*** Test Cases ***

Verify User Endpoint

    Create Session    api    https://jsonplaceholder.typicode.com

    ${resp}=    Get Request    api    /users/1

    Should Be Equal As Integers    ${resp.status_code}    200

    Log    ${resp.json()}

You will be able to send GET, POST, PUT, PATCH, and DELETE requests and handle headers, tokens, and JSON payloads.

Still keyword-driven, even with complicated API workflows, they are all easy to read and maintain.

45. Explain how to use Robot Framework with Appium for mobile testing.

Robot Framework can be used with Appium by using the AppiumLibrary, which allows you to automate testing of both Android and iOS apps.

Here is how to set up:

1. Make sure you have installed the testing requirements:

pip install robotframework-appiumlibrary

2. Make sure to have the Appium Server running either locally or remotely.

Then, write your test like this:

 *** Settings ***

Library    AppiumLibrary

*** Variables ***

${REMOTE_URL}    http://localhost:4723/wd/hub

${PLATFORM_NAME}    Android

${DEVICE_NAME}      emulator-5554

${APP}              /path/to/app.apk

*** Test Cases ***

Launch Mobile App

    Open Application    ${REMOTE_URL}    platformName=${PLATFORM_NAME}    deviceName=${DEVICE_NAME}    app=${APP}

    Click Element    id=login_button

    Close Application

How it works:
AppiumLibrary wraps the WebDriver APIs of Appium so you will still get the same Robot Framework syntax when testing web via the SeleniumLibrary; you will just be targeting mobile UI elements instead. 

In this way, a team organization can unify its web + mobile test automation under one Robot Framework ecosystem.

46. How can you integrate Robot Framework with Git for version control?

Integrating Robot Framework with Git is easy, as Robot tests are just text files.

A typical flow is:

1. Make a Git repository:

git init

2. Then start adding your .robot, .resource, and library files:

git add tests/ resources/ keywords/

git commit -m "Initial commit of Robot tests"

3. Then push up to your remote Git repository, e.g. GitHub or GtLab:

git remote add origin <repo_url>

git push -u origin main

Best practices:

• Keep your libraries and configuration files modular.
• Add large output files like log.html or output.xml to your .gitignore.
• Integrate with CI/CD tools (Jenkins, GitHub Actions, etc) in which each time you commit code you can execute tests automatically.

This encourages collaboration, traceability, and the ability to version your automation Codebase similar to any other modern software development workflow.

47. How do you integrate Robot Framework with other test automation tools?

Robot Framework is very extensible and can easily integrate with other automation tools, in many ways using libraries, APIs, or custom Python wrappers.
Some common examples are:

• Postman or REST APIs – Use RequestsLibrary or custom Python libraries to validate API requests. 
• Database testing – Use DatabaseLibrary or other supported libraries to execute SQL queries against a MySQL, PostgreSQL, or Oracle database. 
• Performance testing – Trigger tools like JMeter or Locust via shell commands from Robot tests. 
• Desktop automation – Use AutoItLibrary or WhiteLibrary for Windows GUI testing. 
• Docker/containers – Execute tests in an isolated and containerized fashion by running tests inside a container. 
• CI/CD tools – Continuous integration with Jenkins, GitLab CI, Azure DevOps, etc. to implement continuous testing.

Since Robot Framework is developed in Python and supports external libraries, almost any test tool or service can integrate with minimal effort.

48. How do you customize the Robot Framework test report?

Robot Framework’s default reports (report.html and log.html) are pretty sharp already, but you can customize them to include your branding, analytics or information.

Typical methods: 

1. Changing metadata in the Settings section:

*** Settings ***

Metadata    Project Name    Mobile Automation Suite

Metadata    Executed By     QA Team

These appear in the report header.

2. Add custom log messages:

Log To Console    Starting Smoke Tests...

Log    Screenshot captured at ${timestamp}    INFO

3. Adding a listener to get your own formatting:
You can add a Python listener that adds some custom HTML, screenshots, or status metrics to the final log:

robot --listener CustomReportListener.py tests/

4. Post-process output XML:

Using the rebot tool:

rebot --name "Final Report" --reporttitle "Automation Results" output.xml

Typically, through listeners and the rebot tool, teams will customize reports to fit their organizational standards or CI dashboard style.

49. How do you debug test cases in Robot Framework?

The practice of debugging in Robot Framework consists mainly of log analysis, selective execution, and the built-in keywords to help you identify the issues.

Here are a few tried and true methods:

1. Use detailed logs

After a test execution, you should always review log.html. Most of the time this will show execution with the keywords in the order they were executed, values of arguments, and full stack traces of errors if there were any.

2. Run in console debug mode

robot --loglevel DEBUG testsuite.robot

Running scripts in debug mode to see detailed runtime messages and variable values is sometimes an ideal way to debug a test case.

3. Use Pause Execution keyword

This will bring up an interactive prompt, where you can run individual keywords step-by-step.

Pause Execution    Check the login page manually.

4. Use Run Keyword And Continue On Failure

This is useful when you don’t want to stop the test after one failed step, but still, want to capture logs.

5. Set breakpoints with Sleep or Log To Console

There are times when just inserting a short pause helps you really see the flow of the test in debug mode.

During interviews, it is good to stress that you never just assume it is an issue with the script: you will go through log.html in depth, validate the test data being used, and allow time for the environment to settle before determining that an issue exists in the script.

50. How do you create custom libraries in Robot Framework?

Custom libraries are created in Python (or Java) when there is no suitable functionality available within the existing Robot libraries.

Typically, creating a custom library is straightforward. The following is the basic structure:

1. Begin by creating a Python file named MyLibrary.py.

from robot.api.deco import keyword

class MyLibrary:

    @keyword("Greet User")

    def greet_user(self, name):

        print(f"Hello, {name}!")

2. Import it in your Robot test suite:

*** Settings ***

Library    MyLibrary.py

*** Test Cases ***

Test Greeting

    Greet User    Ayaan

3. Run it like any other Robot test.

In addition, you can:

Pass arguments while importing it.
 Library MyLibrary.py arg1 arg2

Utilize Python modules or packages for larger scale projects.

In practice, custom libraries provide a way to extend the functionality of keywords, to define business logic in one location, and to eliminate redundancy across teams.

51. How do you create dynamic test cases in Robot Framework?

Dynamic test case creation is useful in that we can programmatically build the test cases rather than writing each individual one. This is particularly useful in data-driven testing as we scale to larger data sets for validation testing.

The creation of dynamic test cases includes two popular ways:

1. Using the DataDriver library

Install it:

pip install robotframework-datadriver

You will reference an external CSV or Excel test data file.

The DataDriver library will automatically create an individual test case for each row of data read from either source.

2. Using Python to generate tests dynamically

You can implement a custom Python file that uses Robot’s DynamicLibrary interface.

from robot.api.deco import library, keyword

@library

class DynamicTests:

    def get_keyword_names(self):

        return ["Test For User 1", "Test For User 2"]

    @keyword

    def test_for_user_1(self):

        print("Running test for user 1")

    @keyword

    def test_for_user_2(self):

        print("Running test for user 2")

This approach allows you the flexibility to build the tests dynamically from responses of an API call, or a configuration file, or database inputs, etc.  It is an ideal implementation for test scenarios at the enterprise scale.

52. How can you implement parallel test execution in Robot Framework?

You can execute tests in parallel in Robot Framework with the Pabot library. Pabot will execute tests in concurrent processes.

Setup:

pip install robotframework-pabot

Run command:

pabot --processes 4 --outputdir results tests/

How it works:

• Pabot has the capability to split your test suites (or test cases) and run suit over many parallel threads, or processes. 
• Each test case will execute in its own process, in isolation, and create its own output XML. 
• When the execution is complete, Pabot will combine all the results in a single report.

Key points to mention in an interview:

• The parallel execution is ideal for massive test suites that could take hours to complete running linearly. 
• You must manage any shared resources, such as browsers, DB connections, or files, with Pabot in parallel execution in an effort to avoid conflicts. 
• Pabot operates well with Selenium, Appium, and API tests.

In summary, Pabot will aid in improving your test execution time drastically. You don’t change your current Robot tests specifically: you simply need to run them in a different way.

53. What keyword will you use to register a mouse hover-over event on any web element?

In Robot Framework (when you are on SeleniumLibrary), you can perform a mouse hover using the keyword:  

Mouse Over    locator

Example:

*** Settings ***

Library    SeleniumLibrary

*** Test Cases ***

Hover Over Menu

    Open Browser    https://example.com    chrome

    Mouse Over    xpath=//div[@id="menu"]

    Click Element    xpath=//a[text()="Submenu"]

    Close Browser

Explanation:

• Mouse Over does the action of performing the same hover that the user is doing with a mouse. 
• Mouse Over is used to invoke functionality for use cases such as drop-down menus or tool-tips or hidden functionality that is displayed to the user after a hover event happens.

If the element does not act upon the mouse hover, you could combine a Wait until Element is Visible or perform a Java script to invoke the JavaScript as a back fall.

Execute JavaScript    document.querySelector("#menu").hover();

So, in a normal interview, you want to share,  or say, if asked, “I will certainly use Mouse Over the mouse hover action, to perform the mouse hover action”.

54. How would you automate the process of image recognition in Robot Framework?

Robot Framework does not automate UI based on image, but it integrates with SikuliLibrary or AutoItLibrary that can help you implement such functionality.

1. Using SikuliLibrary:

Install it:

pip install robotframework-SikuliLibrary

Import the library:

 *** Settings ***

Library    SikuliLibrary

Example test:

 *** Test Cases ***

Verify Image Element

    Open Application    notepad.exe

    Wait For Image    save_button.png    10s

    Click Image        save_button.png

How it works: The SikuliLibrary, specifically, compares images to identify UI widgets based upon images, instead of HTML, so It is useful for checking things like desktop, Flash, or legacy applications.

2. Alternate option:

• Another option is to use ImageHorizonLibrary (which also has OCR).
• You can mix that with the Robot’s built-in Operating System library for hybrid automation.

In an interview you could frame it like this:
“For any image-based testing, I would integrate SikuliLibrary with Robot Framework, as it allows me to find and interact with elements based purely on images.”

55. How do you handle database testing in Robot Framework?

You carry out database testing in Robot Framework through the DatabaseLibrary (or DbLibrary) combined with SQL commands and tests/flow controls to assert test outcomes.

Setup:

pip install robotframework-databaselibrary

Example:

*** Settings ***

Library    DatabaseLibrary

*** Variables ***

${DBNAME}     test_db

${USER}       root

${PASSWORD}   admin123

${DBHOST}     localhost

${DBPORT}     3306

*** Test Cases ***

Validate Database Entry

    Connect To Database Using Custom Params    pymysql    database=${DBNAME}    user=${USER}    password=${PASSWORD}    host=${DBHOST}    port=${DBPORT}

    ${count}=    Query    SELECT COUNT(*) FROM users WHERE email='[email protected]';

    Should Be Equal As Integers    ${count[0][0]}    1

    Disconnect From Database

Supported databases: You can connect to MySQL, PostgreSQL, Oracle, SQL Server, and SQLite, depending on your operating Python database driver. 

Thus, database testing is a simple form of SQL assertions in Robot Framework, and keyword-driven logic will take care of database validation as part of end-to-end testing.

56. How do you handle exception handling in Robot Framework?

Robot Framework has defined several keywords to control exception handling and control flow, mainly through BuiltIn keywords.

Common Examples:

1. Using Run Keyword And Ignore Error

${result}=    Run Keyword And Ignore Error    Click Element    id:submit

Log    ${result}

Runs the keyword and logs an error without stopping the test.

2. Using Run Keyword And Continue On Failure

Run Keyword And Continue On Failure    Page Should Contain    Welcome

3. Using Run Keyword And Return Status
Returns a True/False value for success or failure.

${status}=    Run Keyword And Return Status    Element Should Be Visible    id:popup

Run Keyword If    '${status}'=='False'    Log    Element not visible

4. Try-Except Style using Run Keyword If

${status}=    Run Keyword And Return Status    Click Element    id:nonexistent

Run Keyword If    not ${status}    Log    Element not found, skipping this step

In interviews, it is appropriate to say something like:

“Instead of using the standard try-except syntax like Python, Robot Framework features a set of flexible control-flow keywords that accomplish the same intention, manage recoverable errors so as not to crash the test suite.”

57. What are user-defined keywords, and how are they used in Robot Framework?

User-defined keywords (UDK) are custom keywords you create for the purpose of making test cases easier to read, reducing duplication, and making your scripts easier to maintain.

They act like reusable functions in programming; you define them once and utilize them many times:

Defined inside the same .robot file:

*** Keywords ***

Login To Application

    Input Text    id:username    ${USERNAME}

    Input Text    id:password    ${PASSWORD}

    Click Button  id:login

Then used in a test case:

*** Test Cases ***

Verify Login

    Login To Application

or being defined in a resource file (common_keywords.resource) to be reused in multiple test suites:

*** Settings ***

Resource    common_keywords.resource

Key benefits:

• Provides increased re-usability and modularity
• Makes it easier to maintain test code
• Keeps test cases neat, readable, and business-oriented

So when you are asked about this in an interview, you should mention something like:

“User-defined keywords help us keep things modular and DRY, similar to reusable functions in programming, which will allow us to keep our test suites scalable and easier to debug.”

58. How would you test REST APIs using Robot Framework?

Robot Framework utilizes the RequestsLibrary for REST API testing, which gives you the ability to issue HTTP requests and verify the response with little effort.

Setup:

pip install robotframework-requests

Example test:

*** Settings ***

Library    RequestsLibrary

*** Test Cases ***

Get User Details

    Create Session    api    https://reqres.in/api

    ${response}=    Get Request    api    /users/2

    Should Be Equal As Integers    ${response.status_code}    200

    Dictionary Should Contain Key    ${response.json()}    data

Explanation:

• The Create Session keyword allows you to create a session for your API calls that you can reuse.
• The Get Request performs a GET API call.
• You can also use Post Request, Put Request, Delete Request, etc. to validate your API CRUD methods.
• You can use Should Be Equal or dictionary comparison keywords to validate JSON responses.

You can easily convert this approach to data-driven testing by specifying multiple payloads or endpoints to validate while executing tests on the Robot Framework.

59. Can you discuss a situation where Robot Framework would not be an optimal choice for a project, and what alternative would you suggest?

Yes, Robot Framework is very good at acceptance testing and keyword-driven automation, but It is not necessarily the best option for every project.

There are a few situations in which it would not be optimal:

• Highly complex unit tests or testing algorithmic logic could be cumbersome, as Robot Framework would require writing a lot of logic inside keywords, instead use either pytest or unittest (Python’s native test package). 
• Performance or load testing would require simulating a true concurrent user experience, or a load test, and Robot Framework is not designed to do that, instead, you could use JMeter, Locust, or the same k6. 
• Large scale data processing or data chain APIs tests, when dynamic data handling and control flow are the most important aspects of the test, generally, coding frameworks provide a greater level of control of the tests, pytest + requests or building a test harness in Python would be better. 
• Optimizing CI/CD for speed, when you want to optimize the execution time and have light-weight reporting, Robot Framework can feel quite heavy when compared to code-driven testing other solutions are more efficient regarding syntax versus execution times.

If answering the question in an interview, it would sound something like this: 

“Where Robot Framework shines is acceptance level, cross-team automation, but if I were to encounter a project that required highly technical, low-level unit testing or performance testing, I would suggest pytest or Locust, for example, to support finer control of the scripting, as well as faster runtime for testing.”

60. What are the best practices to improve test execution speed and maintainability in Robot Framework projects?

This is a popular closing question, you are testing the candidate’s appreciation of scalability and the design of frameworks. 

This is a short but complete answer:

Best Practices:

Keep tests modular: Take advantage of resource files and user defined keywords to avoid duplication.

• Use variable files or environmental variables: Centralize the config and it will carry over multiples environments.
• Parallel execution with Pabot: Use Pabot to run test in parallel and speed up testing duration.
• Tagging strategy: Use tagging, smoke, regression, sanity, etc, so you can easily organize tests and run a subset when necessary.
• Don’t restart the browser: For UI tests, use Suite Setup to open the browser one time and maintain the browser through tests.
• Waits should not be a hard coded Sleep statement: Use waits, Wait Until Element Is Visible, for efficient waits.
• Keep a clean directory structure: Separate test cases, keywords, libraries, and resources into different folders.
• Logging and reporting: Use custom log messages sparingly, don’t slow performance down, but still keep reports meaningful.
• Version control and CI/CD integration: Use Git to keep all test assets and run them with Jenkins/GitHub Actions for continued feedback.

Example summary line for interviews:

“Modular design, parallelization, and efficient test data management can reduce test execution time by 40% to 60% with just these three in a large Robot Framework suite.”

Conclusion

The aim of this list of Top 60 Robot Framework Interview Questions and Answers is to give you a solid understanding of how Robot Framework functions, why Robot Framework is widely used for test automation, and how to use Robot Framework with modern tools – Selenium, Appium, Jenkins, and REST APIs.

If you have read through all the chapters from keyword-driven basics to advanced framework customisation, you now have a comprehensive understanding of Robot Framework that is also ready for interview. Keep going! Keep practising! Build your own libraries. Use Robot with CI/CD Pipelines. Use Pabot to run your tests in parallel, and optimise your execution times.

You are now going to be an even better automation engineer if you want to be the person who can not only use a tool, but has the maturity to understand how to use the tool responsibly, effectively, and efficiently in a practical testing environment.

Robot Framework Interview Questions – FAQs