25 Appium Interview Questions for Mobile Testers

Mobile automation interviews have changed since Appium 2 arrived. Interviewers who once asked about /wd/hub and the old TouchAction class now ask how drivers are installed, why capabilities need a vendor prefix, and how you perform a swipe without deprecated APIs. If the Appium interview questions you practised come from a few years ago, your answers may sound outdated.

This list is updated for Appium 2 with the UiAutomator2 and XCUITest drivers, and the Java examples use the current java-client style with options classes. Questions are grouped from fundamentals to real-project problems. For hands-on setup, our Appium tutorial is a good companion.

Key takeaways

• Appium 2 separates the server from platform drivers. Know how to install drivers and why this design matters.
• W3C capabilities need the appium: prefix for non-standard keys; options classes such as UiAutomator2Options handle this for you.
• Prefer accessibility id locators over XPath for speed and stability.
• Use W3C Actions or driver-specific mobile: commands for gestures; TouchAction is gone in recent Java clients.
• Expect scenario questions on flaky tests, real devices, parallel runs and hybrid app contexts.

Appium interview questions on fundamentals (1-7)

1. What is Appium?

Appium is an open-source automation framework for native, hybrid and mobile web apps on Android and iOS, and also supports some desktop and TV platforms through additional drivers. It exposes a WebDriver-compatible API, so you can write tests in Java, Python, JavaScript, C# and other languages without modifying the app under test.

2. Explain the Appium architecture.

Appium is a Node.js HTTP server. Your test script uses a client library to send W3C WebDriver commands to the server. The server routes each command to the platform driver for that session, such as UiAutomator2 for Android or XCUITest for iOS. The driver then talks to the device using the platform’s own automation framework, Google’s UiAutomator on Android and Apple’s XCUITest via WebDriverAgent on iOS.

3. What changed in Appium 2 compared to Appium 1?

The main changes:

• Drivers are no longer bundled. You install them with appium driver install uiautomator2 or appium driver install xcuitest.
• A plugin system lets you extend the server, for example with image-based element finding.
• The default base path is / instead of /wd/hub.
• Only W3C capabilities are accepted, and non-standard capabilities need the appium: prefix.

4. Which drivers have you used?

A good answer names the drivers and why: UiAutomator2 for most Android work, XCUITest for iOS, and possibly Espresso for Android when tighter app synchronisation is needed. Mention that drivers are versioned independently, so you pin versions in your setup scripts.

5. What are desired capabilities?

Capabilities are key-value pairs that tell the server what session to create: platform, automation driver, device and app. Examples include platformName, appium:automationName, appium:deviceName, appium:app, appium:udid, appium:noReset and appium:newCommandTimeout.

6. How do you start an Android session in Java?

import io.appium.java_client.android.AndroidDriver;
import io.appium.java_client.android.options.UiAutomator2Options;
import java.net.URI;
import java.time.Duration;

public class SessionFactory {
    public static AndroidDriver create() throws Exception {
        UiAutomator2Options options = new UiAutomator2Options()
                .setDeviceName("Android Emulator")
                .setApp("/path/to/app-debug.apk")
                .setNewCommandTimeout(Duration.ofSeconds(60));
        return new AndroidDriver(URI.create("http://127.0.0.1:4723").toURL(), options);
    }
}

UiAutomator2Options sets the platform name and automation name automatically and adds the appium: prefix where needed.

7. What is the difference between native, hybrid and mobile web apps?

Native apps are built with platform SDKs and use native UI elements. Mobile web apps run in a mobile browser. Hybrid apps are native shells that display web content inside a WebView. Each needs a different approach in Appium: native locators, browser sessions, or context switching.

Locators and waits (8-13)

8. Which locator strategies does Appium support?

Common strategies are accessibility id, id (resource-id on Android), class name, XPath, and platform-specific ones: -android uiautomator on Android, and iOS class chain and iOS predicate string on iOS. In Java you use AppiumBy, for example AppiumBy.accessibilityId("login").

9. Which locator do you prefer and why?

Accessibility id first, because it works across platforms when developers set it and is fast. Then resource-id on Android or predicate strings on iOS. XPath is a last resort because it is slower and breaks easily when the layout changes. Asking developers to add accessibility ids is a reasonable answer that also improves accessibility.

10. How do you inspect elements?

With Appium Inspector, a separate desktop app that connects to a running Appium session and shows the element tree, attributes and suggested locators. On Android, uiautomatorviewer was used historically, but Appium Inspector is the usual choice today.

11. How do you handle waits in Appium?

Use explicit waits with WebDriverWait and expected conditions, the same as Selenium.

WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(15));
wait.until(ExpectedConditions.elementToBeClickable(AppiumBy.accessibilityId("login"))).click();

Avoid Thread.sleep. Keep implicit waits off or very short if you use explicit waits, because mixing them causes unpredictable timing.

12. How do you scroll to an element on Android?

The UiScrollable approach is reliable on UiAutomator2:

driver.findElement(AppiumBy.androidUIAutomator(
    "new UiScrollable(new UiSelector().scrollable(true))" +
    ".scrollIntoView(new UiSelector().text(\"Settings\"))"));

On iOS, use mobile: scroll with a direction or a predicate.

13. How do you verify a toast message on Android?

With UiAutomator2, toasts can often be located with XPath such as //android.widget.Toast, then you read the text attribute. Toasts disappear quickly, so use a short explicit wait and do not rely on them for critical assertions if a more stable UI signal exists.

Gestures, contexts and device actions (14-19)

14. How do you perform a swipe in Appium 2?

Use the driver’s mobile: gesture commands or W3C Actions. On UiAutomator2:

driver.executeScript("mobile: swipeGesture", Map.of(
    "left", 100, "top", 400,
    "width", 600, "height", 800,
    "direction", "up",
    "percent", 0.75
));

Mention that the old TouchAction and MultiTouchAction classes were deprecated and removed in recent Java client versions.

15. How do you test a hybrid app?

List the available contexts, switch to the WebView, interact using web locators, then switch back.

Set<String> contexts = driver.getContextHandles();
for (String ctx : contexts) {
    if (ctx.startsWith("WEBVIEW")) {
        driver.context(ctx);
        break;
    }
}
driver.findElement(By.cssSelector("#email")).sendKeys("user@test.com");
driver.context("NATIVE_APP");

For Android, the WebView must be debuggable in the build you test.

16. How do you handle the keyboard?

Call driver.hideKeyboard() when it blocks elements. Some teams set capabilities to disable the soft keyboard on emulators. Mention that keyboard behaviour differs between devices, which is a common source of flaky failures.

17. How do you put the app in the background or relaunch it?

Use driver.runAppInBackground(Duration.ofSeconds(5)) to simulate the user leaving the app. To restart, use terminateApp and activateApp with the app package or bundle id. These are useful for testing session persistence and state restoration.

18. How do you handle permission pop-ups?

On Android, the appium:autoGrantPermissions capability grants runtime permissions on install. On iOS, appium:autoAcceptAlerts or appium:autoDismissAlerts can handle system alerts, or you can locate the alert buttons directly. Test at least one flow where the user denies a permission.

19. What is the difference between noReset and fullReset?

With noReset set to true, Appium does not clear app data between sessions, which speeds up runs but can leak state. fullReset uninstalls and reinstalls the app, which is slow but gives a clean start. Most suites use a middle path: clear data or log out in setup.

Real-project and framework questions (20-25)

20. How do you run Appium tests in parallel?

Run each session on a different device with a unique appium:udid. For UiAutomator2, give each session a different appium:systemPort; for XCUITest, a different appium:wdaLocalPort. TestNG parallel settings or a CI matrix can drive the sessions. Our TestNG tutorial covers the parallel configuration side.

21. Real devices or emulators?

Emulators and simulators are cheap and fast for daily runs. Real devices catch issues with performance, hardware, network and manufacturer-specific UI. A common strategy is emulators in CI on every pull request and a real-device run, often on a cloud device farm, before release.

22. What are the challenges of iOS automation?

You need macOS and Xcode. Real-device runs need WebDriverAgent to be signed with a valid Apple developer team, which trips up many first-time setups. Element trees can be deep and slow to query. Mentioning signing and provisioning issues shows real experience.

23. How do you structure an Appium framework?

Similar to a Selenium framework: page or screen objects, a driver factory that builds options per platform, config files for devices and environments, a test runner such as TestNG, reporting, and utilities for gestures and waits. Keep platform differences inside screen objects so tests read the same for Android and iOS.

24. How do you deal with flaky mobile tests?

Find the cause: animations, slow emulators, unstable locators, network calls or leftover app state. Fixes include disabling animations on test devices, using accessibility ids, explicit waits for specific states, resetting data in setup and stubbing unstable backends. Track flaky tests separately rather than hiding them with blanket retries.

25. How do you run Appium tests in CI?

Start the Appium server as a step, launch an emulator (or connect to a device cloud), run the test command and publish reports. Android emulators need hardware acceleration on the CI runner. Many teams use a device cloud to avoid maintaining physical devices.

Quick revision table

How to prepare for your Appium round

Build a small project on a public sample app: login, a scroll, a swipe, one hybrid screen if possible, and runs on two emulators in parallel. Practise explaining your driver factory and how you would add iOS later. Revise core Selenium concepts too, since many follow-ups come from WebDriver basics; our Selenium interview questions help there. Use the official Appium documentation to confirm any capability you plan to mention.

FAQs

Is Appium still used in 2026?

Yes. Appium remains one of the most common choices for cross-platform mobile automation, especially in teams that want one framework for Android and iOS. Some teams also use Espresso or XCUITest directly for faster, platform-specific tests.

Which language is best for Appium?

Java is the most common in Indian job listings, often with TestNG. Python and JavaScript are also well supported. Use the language your team’s other automation is written in.

Do I need a Mac for Appium?

For Android testing, no. For iOS testing, yes, because Xcode and the iOS simulators run only on macOS. Device clouds can reduce the need for local Macs, but you still need macOS knowledge for debugging.

What is the difference between Appium and Selenium?

Selenium automates web browsers. Appium extends the WebDriver protocol to mobile apps and devices. Their APIs look similar, which is why Selenium experience transfers well to Appium.

How many Appium interview questions should freshers prepare?

Freshers should focus on fundamentals: architecture, capabilities, locators, waits and simple gestures, plus mobile testing concepts. The 25 questions here cover the core; depth matters more than quantity.

Conclusion

Set up Appium 2 with the UiAutomator2 driver this week and automate three screens of any sample app, using only accessibility ids and explicit waits. Then follow a structured QA interview preparation plan and check our daily QA jobs page for mobile testing openings.