Top 25 Popular Appium Interview Questions And Answers

This tutorial provides frequently asked Appium interview questions and answers with explanations to help you prepare for the Appium interview:

Appium is an open-source mobile automation UI testing framework to test native, mobile, and hybrid – (combination of native and mobile) web applications. You can test your mobile applications on iOS and Android platforms or using an emulator or simulator. It uses WebDriver protocol for iOS, Android, Mac, and Windows applications.

In order to run Appium on your client machine, Appium server and client bindings for a preferred programming language is required to install. The programming languages preferred by client binding are Java, JavaScript with Node.js, PHP, Python, Ruby, and Robot Framework.

Appium has wrapper or framework that translates selenium WebDriver commands into iOS or Android commands based on device type.

Understanding Appium

Appium Interview Questions

Appium is a mobile test framework that allows test tools, framework, or test practices of our preference; it does not need SDK or recompiling native applications in order to test.

It is built on Selenium WebDriver API and language-specific client libraries, making it a test framework that helps to automate the mobile application. You can use the programming language and test framework of your choice, to develop test automation scripts that are accessible with back-end APIs and DBs.

Suggested Reading =>> Appium Tutorial Review

Most Frequently Asked Appium Interview Questions

Q #1) Describe various types of mobile applications

Answer: Mobile applications are of the following three types:

  • Native Applications: Applications that are created with the help of iOS and Android SDK are Native Applications. Native applications developed in Android will not work on iOS phones and will not be available on iOS App Stores. Native applications designed and optimized for specific platforms offer the best performance, UI/UX suitable to run on that platform, Google Play Store support, offline mode, consistent look and feel, security and data protection, and fewer bugs during development. Some examples of Native applications are the mobile version of WhatsApp, Amazon Prime, Linked In, etc.
  • Mobile Web Applications are actual websites developed in HTML5, accessible by browser, can be accessed offline because of the browser cache. Some examples of mobile web applications are Newspaper as ePaper, Google applications like Drive, Gmail, Docs, Sheets, Forms, and Photos, etc.
  • Hybrid Applications are a mix of native and web applications, like native applications are available on the mobile app stores, and have features similar to native applications, like web applications rely on web browsers to be rendered. Online eCommerce sites and Netflix are some of the best examples of hybrid applications.

Native, Mobile, and Hybrid Mobile Application:


Q #2) What is the difference between iOS and Android?

Answer: Both iOS and Android are used as operating systems for mobile devices. Their differences are listed below:

iOS is mobile operating system developed by Apple for to run all applications on iphone mobiles.Android is mobile operating system developed by Google LLC for mobiles that run on Android.
It has Hybrid type kernel.It has Linux based kernel type.
Developed using objective C and swift language.Developed using Java and Kotlin language.
The default Internet browser used in iOS based devices is Safari.Android devices has Google chrome browser but allow use of any internet browser.
iOS has Siri as Voice Assistant.Android has Google Assistance.
iOS devices can block installation of 3rd party applications on them.Android does not block 3rd party applications.

Q #3) What hardware and software are the prerequisites for using Appium?

Answer: The list of software required before installing Appium is as below:

Hardware requirement:

  • 8 GB RAM Memory
  • Windows 10
  • .Net Framework 3.5 or higher.

Software requirement:

  • Java Development Kit (JDK) – It should have at least JDK version 8 or higher.
  • Android SDK version 22 has separate platforms and build tools, suitable for Appium.
  • Node.js is needed for a non-blocking event-based server to handle multiple WebDriver sessions for iOS and Android platforms.
  • Microsoft WebDriver- also known as WinAppDriver, Appium compatible WebDriver server – Need Windows 10 or above.
  • PDANet+ – It is a free application that converts Android and iOS mobile into Modem and enables tethering.
  • Appium – Client libraries and Desktop application of Appium is mandatory
  • GenyMotion – It is required to run Appium tests in multiple virtual Android devices in parallel.
  • ADT Plugin to access Android SDK within Eclipse.
  • Java Client Drivers are also known as language binding for creating testing in multiple programming languages.
  • Appium Client Libraries supports Appium extensions to WebDriver protocol by Appium Server.

Q #4) List advantages of using Appium.

Answer: It offers the following advantages:

  • It is open-source, supports both iOS and Android
  • We can design an automation script using the same API for Android and iOS.
  • Supports multiple languages like Java, Node.js, Ruby, Python, Robot framework and is cross-platform.
  • Can be integrated with continuous integration tools.
  • Issues like synchronization are avoided.
  • Uses HTTP protocol and is based on Selenium

Q #5) List limitations of using Appium

Answer: Following are some limitations:

  • The time needed, and configuration for Appium set up is complex
  • It can run a single iOS device at a time.
  • There is no support for automation for Android 4.1 or lower.
  • There is no support for Windows for Appium inspector.
  • Limited support for testing hybrid applications.
  • You cannot test the switching action of native to the web or vice versa.

Q #6) Explain the working of Appium

Answer: The working of Appium is explained below:

  1. Appium server developed using Node.js implements selenium WebDriver.
  2. The connection request is sent by WebDriver script to Appium server via JSON Wire protocol.
  3. Automation session and desired capabilities are set
    • In case of Android, the request is sent to UIAutomator, UIAutomator communicates with bootstrap.jar running on an Android mobile device or emulator to perform operations.
    • Whereas for iOS, UIAutomation receives requests. UIAutomation communicates with bootstrap.js running on iOS mobile devices or emulators to perform operations.
  4. After execution of the request sent, the message is sent back to the Appium server. The results of execution are captured by server logs.

Working of Appium:


Q #7) Describe the JSON wire protocol used in Appium.

Answer: JSON wire protocol uses RESTful API to communicate between Appium client and server, controls behaviors of mobile phone in addition to setting communication stream.

Q #8) List locators used in Appium

Answer: List of locators support is as below:

  • ID
  • Class Name
  • XPath
  • Accessibility ID
  • Android UI Automator
  • iOS UI Automation
  • Android View Tag using Appium Espresso

Q #9) List difference between Selenium WebDriver and Appium WebDriver

Answer: Selenium and Appium both use

  • JSON wire protocol
  • Methods like
    • sendKeys(),
    • findByClassName(),
    • findByElementId(),
    • findByXPath()

There is a difference between Selenium WebDriver and Appium WebDriver as below.

Selenium WebDriverAppium WebDriver
Supports mobile web applications using browsers like Firefox, Chrome, Opera, Safari Supports native mobile application installed on iOS and Android devices
It has become standard for automation testing of browser based web applicationsRemoteWebDriver class is inherited by Appium WebDriver class. This class with help of Appium server provides additional functions useful in context of mobile test automation.

Q #10) What is selendroid?

Answer: Selendroid is a mobile automation tool for Android-based applications that uses selenium WebDriver client API. It uses inspector for monitoring the current UI status.

Q #11) List the activities possible with the real device but not with the emulator.

Answer: The list of functionalities that are not possible with an emulator is as below:

  • Make or Receive Calls, Send or Receive SMS,
  • Battery issues, GPS tracking, Gesture recognition, touch screen functionality
  • Changing Color over the screen, widgets, accessing the file
  • Selecting icons to access the application with help of fingers (touch screen),
  • Typing the text, moving the mouse on a real mobile screen will differ from that of an emulator.
  • Performance tracking of the installed mobile application, etc.

Q #12) What is Espresso?

Answer: Espresso is a test automation framework for Android. It is a UI automation framework suitable for black-box testing that uses JUnit4 annotations. The tests in Espresso are written using Java and Kotlin. Appium uses Espresso with Android View Tag.

Q #13) What is XCUITest?

Answer: XCUITest is an automation framework for iOS. This framework is used to test only native mobile applications that are built using swift or objectives C. XUITest cannot write tests for multiple platforms. Appium uses the XCUITest driver for automating iOS applications.

Q #14) List some common exceptions in Appium observed during test automation?

Answer: Following are some commonly encountered exceptions in Appium during script execution:

  • SessionNotFoundException: On disconnection of Appium connection or Session not established, display this exception
  • ElementNotFoundException: When Appium does not find the element it is looking for, this exception is displayed
  • WebDriverException: When Driver does not exist, this exception is displayed
  • NoSuchContextException: is thrown when the context target that is to be switched to does not exist.

Q # 15) List the differences between the working of Appium on Android and iOS.

Answer: Appium executes tests differently on Android and iOS-based mobile.

  • Appium uses the UIAutomator framework of automation when tests Android-based mobile applications.
  • Appium on the iOS mobile device uses Apple’s XCUI Test API to interact with UI elements to test their functionality.
  • UIAutomator connects with bootstrap.jar being executed in simulator/emulator or real device that performs client operations.
  • XCUI Test in case of iOS mobiles communicates with bootstrap.jar
  • Bootstrap.jar acts as a TCP server that accepts test commands to test the functionality of Android-based mobile that uses UIAutomator.
  • Bootstrap.jar performs the action on the iOS mobile application being tested, Appium Client sends a message with log details of commands executed.

Q #16) List the essentials you need to write the Appium test?

Answer: The essential things required are:

  • Driver – Set of APIs help write tests and commands are sent to HTTP Server for processing,
  • Session – Session instances should be created during execution of automation testing and closed after execution,
  • Capabilities – Set up of Chrome Driver path to execute tests in Chrome browser and defining params like PlatformName, PlatformVersion, and DeviceName,
  • Commands – Appium requires commands that are action words that perform test steps.

Q #17) Describe desired capabilities in Appium

Answer: Desired capabilities are keys and values inside JSON objects sent by Appium client to server to perform all the actions required to test the functionality.

Q #18) What are the properties present in key-value pair in desired capabilities?

Answer: Few of the properties are explained that are present in keys and values form in desired capabilities as below:

  • automationName: Provides name of the automation engine that will be used. Appium is used by default, and Espresso, UIAutomator1 & 2 for Android, whereas XCUITest for iOS.
  • platformName: Name of mobile OS platform being used, for example, iOS, Android or FirefoxOS
  • platformVersion: Version of mobile OS such as 7.1, 4.4, etc.
  • deviceName: Mobile device or emulator type – iPhone Simulator, Android Emulator, etc.

Q #19) List design considerations in Appium

Answer: Following are some points taken into consideration in Appium Design:

  • Node.js should be installed already on the system as Appium Server is actually a HTTP server designed using Node.js that drives iOS and Android sessions with help of WebDriver JSON wire protocol.
  • Appium server installed on system acts as REST API.
  • Appium server receives connection and command requests whereas command executes on iOS/Android devices.
  • Appium server sends HTTP responses to interact with the user interface using the mobile test automation framework.
  • There are various frameworks for
    • iOS mobile devices
    • Google UI Automator for Android API level 16 or higher
    • Selendroid for Android API level 15 or higher

Q #20) Explain implicit and explicit wait in Appium

Answer: Appium Web Driver checks the web element or certain conditions with the help of locators, various waits are applied during the execution of automation script are explained below:

Implicit Wait: Web Driver will make automation script wait for a certain time period in search of web element. After this time, If the element does not display, the error “No such Element found Exception” will be thrown.


driver. manage(). timeouts(). implicitlyWait (TimeOut, TimeUnit.SECONDS);

Explicit Wait: The Web Driver will wait for certain condition OR will throw “ElementNotVisibleException” exception after maximum time for wait exceeds,

Some of the conditions for explicit wait are:

  • alertIsPresent(),
  • elementToBeClickable()
  • presenceOfAllElementsLocatedBy()
  • textToBePresentInElement()
  • visibilityOf()


WebDriverWait wait = new WebDriverWait(driver, 15); 
wait.until(ExpectedConditions.textToBePresentInElement(By.xpath("xpath"), "Text"));

Q #21) List common pitfalls you should avoid while writing Appium tests.

Answer: While writing Appium tests following points should be taken into consideration:

  • Avoid excessive use of XPath as a locator.
  • Use accessibility ID locator for both iOS and Android mobile device testing.
  • Querying for visibility of elements should only be restricted for important elements.

Q #22) What is the purpose of Appium Inspector?

Answer: Appium Inspector is a utility provided by the Appium automation framework that helps to load mobile applications and locate elements.

Q #23) Describe ways to debug Appium tests.

Answer: Following are some ways we can do:

  • Any error that occurred during mobile tests can be traced from the logs generated at the Appium server.
  • Test scripts created can be debugged with the help of the programming language used in writing these tests.

Q #24) How can we retrieve the test status of Appium test execution?

Answer: There are various ways to display the test status:

  • Integrating TestNG with Appium
  • ExtentReports that give test status reports in the dashboard
  • REST API of BrowserStack App Automate for .apk (Android app) or .ipa (iOS app).
  • Built-in reporting tools like Maven and Allure

Q #25) What is Calabash?

Answer: Calabash is a mobile test automation framework for testing mobile devices based on iOS and Android platforms, tests written using Cucumber, Gherkin, and Ruby code.

Also Read =>> Appium Tests for Android App


Appium is an industry-standard for mobile automation framework to test the functionality of native, hybrid, and web-based applications on iOS and Android mobile devices.

Various questions such as configuration needed before installation, working of Appium, Pros and Cons of its use, internals, and design considerations have been answered.

Mobile testing is the process of testing the mobile applications on iOS and Android devices, simulators, and emulators for usability, functionality, and consistency. Appium is used as a mobile automation test framework for Android and iOS mobile applications, Espresso is for Android-based mobile testing whereas XCUITest is for iOS-based mobile testing.