Waldo sessions now support scripting! – Learn more
App Development

Appium Tutorial: Your Complete Intro to Mobile Testing

Juan Reyes
Juan Reyes
Appium Tutorial: Your Complete Intro to Mobile Testing
June 2, 2023
min read

Hey there, mobile app enthusiasts! In this post, we'll delve into the world of Appium and mobile testing. First, we'll discuss what Appium is, its pros and cons, and how it works.  Finally, we'll address some common issues and limitations of Appium and explore an alternative no-code testing platform called Waldo. So let's dive right in!

Appium is an open-source mobile app testing framework that automates testing for native, hybrid, and mobile web applications

What Is Appium and Why Use It?

Appium is an open-source mobile app testing framework that automates testing for native, hybrid, and mobile web applications. It's designed to work across multiple platforms, including Android, iOS, and Windows. Appium's main advantage is its ability to run tests on real devices, emulators, and simulators, allowing you to ensure your app is functional and bug-free.

Advantages of Appium

One of the significant advantages of Appium is its cross-platform support, which allows you to write tests once and run them on multiple platforms, such as Android, iOS, and Windows. This means you can save time and effort when testing your mobile app across different devices and operating systems.

Another appealing aspect of Appium is its language-agnostic nature. This means you can write tests in your preferred programming language, be it Java, Ruby, Python, or JavaScript. This flexibility allows you to leverage your existing programming skills and knowledge when creating test scripts, making the testing process more efficient and enjoyable.

Lastly, Appium's open-source nature is a considerable advantage. Being free to use, it provides an accessible and cost-effective option for developers and organizations of all sizes. Additionally, the large and active community surrounding Appium continually improves and supports the framework, ensuring it stays up to date and relevant in the ever-evolving world of mobile app development and testing.

Potential Disadvantages of Appium

While Appium offers several benefits, there are potential disadvantages that users should be aware of. One such drawback is the requirement for programming knowledge, as Appium test scripts need to be written in a supported programming language. This requirement might pose a challenge for those new to programming or requiring more experience in the languages that Appium supports.

Another issue with Appium is that tests rely on accessibility IDs, which can change as your app's user interface (UI) evolves. This can lead to flaky tests that fail unexpectedly or require constant updating to stay in sync with the latest UI changes, resulting in a less stable testing process.

Moreover, the reliance on accessibility IDs can increase test maintenance work over time. As IDs change or need updating, developers must devote additional time and resources to maintaining these elements within the test scripts, potentially detracting from other essential development tasks.

Appium also requires testers to anticipate the specific bugs they want to test for, which can be challenging in practice. This approach may inadvertently allow some bugs to slip through the cracks, as it's not always easy to predict every issue that might arise in a mobile app.

Finally, it's essential to note that Appium is not an infrastructure provider. This means that to utilize Appium's capabilities fully, you'll need to invest in and integrate with other infrastructure providers, such as device farms or cloud-based testing solutions. This additional investment may add complexity and cost to your mobile app testing process.

Appium Architecture and How It Works

Appium's architecture is based on a client-server model. The Appium server processes commands from the client, which contains your test scripts, and communicates with the mobile device or emulator/simulator to execute the test.

To gain a deeper understanding of Appium's workflow, let's break it down step by step:

  1. A client sends a command: The process begins with the client (your test script) sending a command to the Appium server. This command represents an action or operation to be performed within the mobile app during testing.
  2. The server interprets the command: Upon receiving the command, the Appium server interprets it and identifies the appropriate platform driver required for the test (e.g., Android or iOS).
  3. The platform driver communicates with the device: The platform driver then communicates with the mobile device, emulator, or simulator, instructing it to execute the specified command within the app.
  4. The device returns the result: Once the command has been executed, the device, emulator, or simulator sends the result back to the platform driver. This result may include information about the success or failure of the command, as well as any relevant data or output.
  5. The platform driver sends the result to the server: The platform driver then relays the result back to the Appium server, completing the communication loop between the device and the server.
  6. The server returns the result to the client: Finally, the Appium server sends the result back to the client (your test script), allowing you to analyze the outcome of the command and make any necessary adjustments to your app or test script.

Getting Started With Appium: A Short Tutorial

Before we jump into the tutorial, let's discuss the prerequisites for using Appium.


  1. Basic programming knowledge in a language supported by Appium (e.g., Java, Ruby, Python, or JavaScript)
  2. A mobile app to test, either as a native or hybrid app
  3. Familiarity with mobile app development and testing concepts

Installing Appium

To begin installing Appium, first, you need to ensure that Node.js is installed on your machine. If you don't have it installed already, head over to the official website and download the appropriate version for your operating system. Then proceed with the installation process.

Once Node.js is installed, open your command prompt or terminal. To install Appium globally on your machine, enter the command `npm install -g appium`. This command utilizes the Node Package Manager (npm) to download and install Appium, making it accessible across your entire system.

After the installation is complete, it's a good idea to verify that everything was installed correctly. To do this, simply type `appium -v` in your command prompt or terminal. If the installation was successful, this command will display the installed version of Appium. With Appium now installed, you're ready to start creating and running your mobile app tests.

Setting Up Appium

To set up Appium for mobile app testing, you must follow several steps to ensure the appropriate platform-specific tools and drivers are installed and configured.

First, download and install the necessary platform-specific tools and SDKs. For Android, this means downloading and installing Android Studio, while for iOS, you'll need to install Xcode. These tools provide essential components and utilities for app development and testing on their respective platforms.

Next, configure the environment variables for the platform-specific tools. This process involves setting up the correct paths to these tools within your system's environment variables, allowing Appium to interact with them efficiently during testing. Again, the configuration process may vary depending on your operating system, so make sure to consult the documentation for Android Studio or Xcode for specific guidance.

Finally, you'll need to install the appropriate platform-specific driver for Appium. These drivers enable Appium to communicate with your mobile app on the targeted platform. For example, if you're testing an Android app, you'll need to install the `appium-android-driver`, while for iOS apps, you'll require the `appium-xcuitest-driver`. To install the driver, use the npm command in your terminal or command prompt, like so: `npm install -g appium-android-driver` or `npm install -g appium-xcuitest-driver`.

With these steps completed, your Appium setup is ready to go, and you can begin writing and executing mobile app tests for your chosen platform.

Testing a Mobile App With Appium

When you're testing a mobile app with Appium, the first step is to write your test script using your preferred programming language, such as Java, Ruby, Python, or JavaScript. To do this, you'll need to utilize an Appium client library corresponding to your chosen language. Next, your test script will contain various test cases and commands that define how the tests should interact with your mobile app during the testing process.

Once your test script is ready, you must start the Appium server. To do this, open your terminal or command prompt and run the `appium` command. The Appium server will now be active and ready to receive commands from your test script.

With the Appium server running, you can execute your test script. As the script runs, the Appium client will send commands to the Appium server, which, in turn, will interact with your mobile app on the target device, emulator, or simulator. This process allows the tests to be executed within the app's environment, ensuring accurate and reliable results.

After completing the tests, take some time to analyze the results. This analysis will help you identify any issues or areas for improvement within your mobile app. Based on these findings, you can make any necessary adjustments to your app or test script to ensure your app performs optimally and meets user expectations.

Appium, Android, and Node.js

Here's an example of testing a mobile app with Appium using Node.js:

1. Ensure you have the necessary prerequisites:

  • Node.js installed on your system
  • Android Studio (for Android SDK) and an emulator configured
  • Appium server installed and running

2. Create a new directory for your project and navigate to it in your terminal or command prompt.

3. Initialize a new Node.js project by running the following command:

    npm init -y

4. Install the Appium client and the necessary dependencies by running the following command:

    npm install appium appium-webdriverio webdriverio

5. Create a new JavaScript file (e.g., `appium_test_example.js`) and add the following code:

    const { remote } = require('webdriverio');

    async function runTest() {
      const opts = {
        path: '/wd/hub',
        port: 4723,
        capabilities: {
          platformName: 'Android',
          deviceName: 'Android Emulator',
          appPackage: 'com.example.myapplication',
          appActivity: '.MainActivity',
          automationName: 'UiAutomator2',
          noReset: true
      const client = await remote(opts);
      // Locate the text field and enter some text
      const textField = await client.$('#com.example.myapplication:id/text_field');
      await textField.setValue('Hello, Appium!');
      // Locate and click the submit button
      const submitButton = await client.$('#com.example.myapplication:id/submit_button');
      await submitButton.click();
      // Wait for the result element to appear
      const resultElement = await client.$('#com.example.myapplication:id/result');
      await resultElement.waitForDisplayed();
      // Get the result text
      const resultText = await resultElement.getText();
      console.log('Result:', resultText);
      // Close the session
      await client.deleteSession();

Make sure to replace the `appPackage` and `appActivity` values with the appropriate values for your app.

6. Save the file and run the test by executing the following command in your terminal or command prompt:

    node appium_test_example.js

The script will launch the Appium server, connect to the Android emulator, interact with the text field and submit button of your app, and retrieve the result text. Finally, it will print the result to the console.

That's it! You have now run a basic mobile app test using Appium and Node.js. Feel free to expand on this example and add more test cases as needed.

Common Issues and Limitations of Appium

Appium, while a powerful tool for mobile testing, does come with its share of limitations and challenges that users might encounter. One such challenge is the steeper learning curve associated with Appium. As it requires knowledge of programming languages and mobile app development concepts, those new to the field may need help getting started with Appium.

Another area that users might need help with is flaky tests due to UI changes in their apps. As the app's UI evolves, accessibility IDs used by Appium may also change, leading to unstable tests that require constant maintenance. This need for maintenance can be time-consuming and detract from other crucial development tasks.

The reliance on accessibility IDs also contributes to increased test maintenance work over time. As IDs change or need updating, developers must devote additional resources to maintaining these elements within the test scripts, which can significantly burden the development process.

Lastly, infrastructure integration can be challenging, as Appium is not an infrastructure provider. To fully leverage Appium's capabilities, users will need to invest in and integrate with other infrastructure providers, such as device farms or cloud-based testing solutions. This additional investment may add complexity and cost to the overall mobile app testing process, making it harder for some organizations to adopt Appium as their primary testing solution.

Situations Where Appium Might Not Work for Your Organization or Architecture

In certain situations, Appium might not be the best fit for your organization or architecture. One such scenario is when your team needs more programming skills or experience with mobile app development and testing. In this case, the learning curve associated with Appium might prove to be a significant barrier, and seeking alternative testing solutions may be more practical.

Another instance where Appium might be unsuitable is when your app's UI frequently changes. Since Appium tests rely on accessibility IDs, constant UI updates can make it challenging to maintain stable tests, as IDs might change or require updating regularly. In this situation, exploring other testing options that are less affected by UI changes may be more efficient.

Lastly, if your organization needs a faster, more straightforward way to create and maintain tests without requiring extensive programming knowledge, Appium may not be the best choice. In such cases, it might be more beneficial to consider no-code or low-code testing platforms that offer a more user-friendly and accessible approach to mobile app testing.

Introducing Waldo: A No-Code Testing Platform

If Appium isn't the perfect fit for your needs, consider exploring Waldo, a no-code testing platform for mobile apps. Waldo offers a simple, intuitive way to create and maintain tests without the need for programming knowledge or extensive app development experience.

There are several benefits to using Waldo over Appium for your mobile app testing needs. One significant advantage is that Waldo provides an all-in-one solution, eliminating the need to invest in additional infrastructure providers. In addition, this comprehensive approach streamlines your testing process and reduces complexity.

Another benefit of Waldo is that its tests don't require programming knowledge or experience, making the platform more accessible to a broader range of users, including those without a coding background. Moreover, this inclusive approach ensures more team members can contribute to the testing process and improve app quality.

Waldo's tests also demonstrate greater resilience to UI changes, which reduces the likelihood of encountering flaky tests. This stability ensures a more reliable testing experience and helps maintain the overall quality of your mobile app.

Additionally, Waldo's more stable approach to test creation results in reduced test maintenance work over time. This reduction allows your development team to focus on other essential tasks, improving efficiency and productivity.

Lastly, Waldo's tests don't rely on anticipating specific bugs, meaning you can catch more issues, even when tests pass. This comprehensive approach to testing ensures that your mobile app meets high-quality standards and delivers an exceptional user experience.

Wrapping Up

Appium is a powerful and widely used mobile testing framework with many advantages, but it has some limitations and challenges. For those who find Appium's learning curve or maintenance requirements too steep, Waldo offers an alternative no-code testing platform that simplifies the testing process without sacrificing effectiveness.

Now you have a better understanding of Appium and how it works and an alternative testing option in Waldo. With this knowledge, you can make an informed decision on the best mobile testing solution for your organization's needs. Happy testing!

Automated E2E tests for your mobile app

Waldo provides the best-in-class runtime for all your mobile testing needs.
Get true E2E testing in minutes, not months.

Reproduce, capture, and share bugs fast!

Waldo Sessions helps mobile teams reproduce bugs, while compiling detailed bug reports in real time.