Appium Reviews

We use Appium to test our native applications for iOS and Android. The solution is deployed locally and integrated into our instance of GitHub Actions for CI/CD functionality, so it's a hybrid deployment. 

Using Appium with React Native allows us to reuse our tests for both Android and iOS. If we had to use one tool for Android and another for iOS, we would need two repositories, two tests, and a lot more coding for us to do. I think React Native is the only real solution available nowadays for black box testing the way we prefer to do it.

We develop apps using the React Native framework, and Appium integrates well for testing those apps. The Appium automation framework also has good integration with GitHub Actions and plenty of other tools and frameworks, including BrowserStack. 

Appium also offers plenty of testing interactions, including swipes and other actions. It provides more interactions compared to other solutions like Selenium HQ, which is another tool we work with.

Appium Inspector is another excellent feature that provides us with a lot of information when dealing with app elements. One of our uses for this is determining which selectors are faster, as we want our apps to be as fast as possible. 

We previously worked with native applications, and there weren't any good mobile app testing tools. We started working with React Native, which works well with Appium, but it would be good to see better integration; the way elements are displayed can be messy. React Native is very popular nowadays, so it's essential to have that compatibility.

Appium doesn't recognize IDs placed by our developers on nested elements when we use React Native for iOS; it just sees the whole page and one element. We use coordinates to get around this, but it isn't the best system, and nobody in the community has been able to help us.

iOS is also strict in general when it comes to signatures and developer accounts, which creates additional headaches for iOS testing compared to Android. It would be great to see a more streamlined setup for iOS, but that might be more of an Apple issue than an Appium one. 

We have been using the solution for about four years. 

The solution is relatively stable, but sometimes tests can become flaky. This could be because of Appium, or due to a cloud-related issue, it isn't exactly clear. It's more stable than it was four years ago, so the product has improved, but there is still room for better stability. 

The solution is scalable. Once it's installed on the machines or in the cloud, everyone can run it and I don't think it matters how many staff members use it. We have nine end users in our organization. 

Appium is an open-source solution so there isn't a number to call for technical support. However, there is a large user community, so it's easy to find help for issues. 

The initial setup is very straightforward; it's just a download with a desktop installation. Setup time depends on your internet, but I would say it takes minutes.

Appium is open source; we can use it for free.

We looked at Espresso and XCUITest, which are native testing apps for Android and iOS, respectively, but we can't use those for both in React Native. We carried out a POC for Appium, and there were no viable alternatives. It allows us to use one tool and one repository for both mobile operating systems.

I would rate the solution eight out of ten. 

Appium is a great tool, and I recommend it. Working with iOS requires patience, and setup can be somewhat demanding, but there are no such problems with Android. Overall, the solution does what we need it to do.

It's for automating mobile testing. It's related to the engineering side. It's a tool used by engineers for automating apps in the mobile world, for testing, like doing manual testing and automation testing. So, it's an okay customer thing.

It's an open-source tool. You can handle the application stuff with different programming languages. With those, we can use it anywhere for automating mobile apps.

There is room for improvement in stability. It breaks down.

I have been using it for three to four years. 

It breaks down. It's open-source, and it will have bugs. I rate it, like, three out of five.

So it has some issues.

It is a very scalable product. It can be used with different programming languages.

And we can use it for multiple devices, like thousands of devices.

It's like open-source, like, a kind of community support.

There is no, like, it's an open-source application. There's no, like, designated support team. Anyone from the community will help.

We need to have some experience to set it up. 

It's open source, so it's completely free.

It's for automation testing of mobile apps. If you want an open-source tool, you can go for it.

Appium helps me to do as much as much as I want to. 

The tool needs to add a dependency manager. 

I have been using the product for three to four years. 

I rate the tool's stability an eight out of ten. 

I rate Appium's scalability an eight out of ten. My company has five users. 

Appium's deployment is straightforward. 

I rate Appium an eight out of ten. 

Our primary use case addresses customer requirements from the healthcare domain, a few from the construction domain, and logistics.

The automation part is extremely helpful in streamlining our processes.

There is always a concern about the amount of code that is required to enhance the automation process. The idea of having less code or no code is what we would like to see in future updates. Increase performance, battery, load testing, and no-code less, more advanced topics which we can bring to the tool features. If we can make it lightweight and clear to understand and in an easy way, that will make this tool even more worthwhile.

I have been using Appium for the past six years.

Appium is definitely stable.

Appium is scalable and we plan to increase it in the future.

The initial setup is straightforward and not that complex, There is a little procedure that we need to follow in the setup, and then just go ahead and run it. You may need to write a little bit of scripting here and there to connect with the respective code. But it is all possible and quick.

We did the implementation in-house. It is just a specific process to get setup and then deploy.

The price is good for people to be able to make a favorable decision for the value.

I would rate Appium a nine out of ten.

The primary use case of the solution was to automate a mobile Android app that was related to IP configuration cameras to design their system and to run those cameras using the app.

I found the Appium Inspector to be the most valuable feature because it helps to write the scripts down.

The solution can be improved by granting more flexibility around integration with app activity ID, which is sometimes not easily available for automation engineers to configure.

There is room for improvement with the scalability of the Appium server interaction.

I would like a feature to allow for iOS automation without having to use Apple Xcode.

I have used the solution on multiple occasions throughout the years. The last time I used the solution was around nine months ago.

The latest versions of the solution are stable.

The solution is scalable. 

The initial setup is straightforward if you have previous experience with the solution, but it can be complicated for a novice user.

The solution is open source.

I give the solution eight out of ten.

There are a lot of helpful documents available online if you require support with the solution.

When it comes to mobile automation, I recommend this solution because of its performance, and scalability over the competition.

We primarily use the solution for UI validation of mobile applications. It's a mobile development platform. We have an application where we have to test the front end and how it is cloning.

It's easy to connect the product. Within a single command, we can easily connect to the device. The connectivity is just that easy.

We get a list that shows all devices that are connected to the system.

It is a very easy initial setup.

Support-wise, it could be better. Whenever we get some issues, it may take some time. I'd like them to be more responsive. 

There's not too much public documentation or information. If we Google information or something else regarding the Appium, there won't be much compared to Selenium. Selenium is also open-source. Appium details are limited.

It is difficult to understand. Recently, there were major changes in Appium. Understanding those changes, was a bit difficult. There just wasn't enough transparency.

I've been using the solution for one and a half years. 

The solution is pretty stable. That said, either from the application side or the Appium side, sometimes, I get some error that is not correct. Even if the application is open, sometimes it throws some error, however, maybe it is from the emulator side. I'm not sure. 

If I run the same test case, and in the same execution, I don't see that error again. It's random, yet may be from our side. I don't think it's from Appium. However, I'm not sure. 

The solution is scalable. The capacity is very good. 

We have three QAs using the product.

Technical support is not as responsive as we would like them to be. They often are late to reply. Sometimes to topic diverts towards something else. It's open-source, which means support is always a bit of an issue. 

Neutral

We also have used Selenium, which has more information available. Selenium is also open-source. Both are pretty similar. 

The solution is very easy to set up. It's not an issue at all. It took one or two days to connect the emulators. It was pretty simple and straightforward. 

I'd rate the initial setup at a five out of five in terms of ease of deployment. 

This is an open-source tool.

We are end-users. We tend to use the solution on a weekly basis.

I'd rate the solution at an eight out of ten. 

It's normally used to test mobile applications, and to interact with some power applications. It's mainly for mobile testing applications?

I like the app inspector. It's quite a good and useful tool for us. I like that we can use it almost out of the box. 

It works well on Android. 

The solution is stable.

It's very scalable. 

The solution is free to use. 

I'm facing a lot of issues with my new juniors when they set up Appium for iOS. For Android, it's easy, however, for iOS to interact with it on iPhones or something. It requires some additional libraries and some additional installation. Sometimes it's not working. While Android works well, iOS continues to be an issue. 

There are a lot of issues on GitHub discussions and Stack Overflow, et cetera, and it's still not resolved. When we use Appium Inspector and just Appium, we are not able to inspect nest elements. Half of the elements are nested. Especially for React Native, it's not visible in Inspector, and we cannot interact with this element. We need some bug fixes for nested elements. 

We'd like a one-button click where you hit it, and everything is automatically installed. 

I've used the solution for three or four years, maybe less. 

Generally, I'm not facing any issues with stability, so I am quite satisfied. There are no bugs or glitches. It doesn't crash or freeze. 

I'm not facing any issues with scalability. It's not a problem to expand. 

We have a team of ten using the solution right now. We use it on a daily basis. We have daily test runs, using Appium, and have test cases to update, to add on a daily basis.

We have zero direct interactions with Appium. If we need help with something, we just use some resources from the internet or some documentation. Aside from eh issues we've had with nested elements, this has always been enough for troubleshooting. 

I have no experience using other automation tools for our devices. We only use Appium.

It's not difficult to set up and deploy. However, it does take time. We use Macbooks. We don't use Windows. It's more complicated to set up on iOS than on Windows. It can take two to four hours to configure everything once you have it deployed. For example, if you have ten devices, the time is two to four hours each, so it can take a while. 

I'd rate the solution two or three out of five in terms of ease of deployment. 

This is a free tool. 

Based on the issues we've had, I'd rate the solution six out of ten. 

Our use case for Appium is writing end-to-end tests for mobile applications. We also use it for some data extraction for an end-to-end user desk.

For the particular use case we used Appium for, we felt that it served our purpose completely, and we haven't had any issues with the Python Client for Appium. Appium has been a good solution for us.

I haven't explored other solutions in this particular area, but what I like best about Appium is the fact that it shares functions with Selenium. The extension of Selenium functions allows me to use all of the methods that exist in that domain, and it just makes it simpler for me. I've been using Selenium for some time as well, so using Appium just seems like a natural fit for me.

What needs improvement in Appium is its documentation. It needs to give more context on the libraries that Appium is using under the hood. For example, my team is using Appium for Android automation, and a lot of times, I feel that there's functionality that's available through the Appium interface, that exists within the UIAutomator, but there aren't a lot of useful or helpful resources on the internet to find that information, so it would be good to have some linkage with the underlying platform itself.

Another room for improvement in Appium is that it's buggy sometimes. For example, at times, there's a bug in the inspector application that doesn't allow me to save my desired capability set, so it would be nice to get that bug fixed, but overall, Appium is a good tool.

The Touch Actions functionality in Appium also needs improvement. For example, if I want to initiate a scroll on the device that I'm running Appium on, sometimes Swipe works, but in other situations, I have to explicitly use action chains, so I'm not too sure what's the better approach.

What I'd like to see in the next version of Appium is a more intelligent and more intuitive AppiumLibrary, in terms of identifying menus and scroll bars, etc., because right now, I'm unsure if I have to do a lot of export reversals to get to the elements I'm looking for. It would be nice to have some functionality built in, which would allow me to easily get those exports.

I've been using Appium for almost two and a half years now.

Appium is stable so far, performance-wise. I never had any performance issues with Appium scripts, and I could potentially do as many Appium programs as I want, and I'd only be limited by the compute capacity of the particular machine that I'm running it on, so no issues there.

Appium has decent scalability, and I've primarily used the Appium-Python-Client. What the Appium team could look into would be the possibility of running Appium in a cluster because currently, there's not a lot of in-depth documentation on how to do it.

For example, the way Selenium Hub works with Kubernetes, if Appium can have that functionality of working with Kubernetes, then that would ensure the greatest scalability for Appium.

I've never had to reach out to the Appium technical support team. I'm not even aware of the support channels for Appium, but I haven't had to reach out ever.

I wasn't sure of what other solutions existed out there. I just came across Appium, and I thought that Appium suits my use case, and it's open source, so that helps.

The initial setup for Appium wasn't as straightforward. I was an individual contributor that pitched this idea to my organization about using Appium, and I was solely responsible for researching it, writing code, then deploying it. It wasn't too straightforward, but in the end, I was able to get it done.

I did the deployment of Appium all by myself.

There were implicit monetary benefits that have come from our use of Appium, so ROI wasn't explicit. We got cost savings, reductions in downtime, stability, etc., from using Appium, which translates to ROI.

I'm unsure if there's any cost associated with Appium. I got the free package which includes the server GUI application and the inspector application, and it was free to download, and that's all I need to get my work done.

I'm not aware of any additional costs associated with the tool. Essentially, if you want to run Appium in a production environment, you'll need to hook it up with an emulation service, and though that's outside the scope, that has to tie and deliver the entire solution.

I'm using the Appium-Python-Client version 2.1.2.

In my company, between four to five people use Appium.

The number of people required to maintain Appium depends on the number of tests you've written. In my company, a single person can maintain it.

Right now, Appium is being used pretty extensively within the company. My team runs and tests four to five different applications, and that list will be extended, so usage of Appium will go up in the future. It's not going to go down.

The advice I would give to anyone on Appium for the first time is to look into the underlying automation, for example, the UIAutomator for testing. I would urge you to also look into the different functionalities offered by the base automation and essentially use those features provided by the base automation within that context because that's going to give you the biggest branch of data.

My rating for Appium is seven out of ten, based on the work I'm doing on it.

My company is a customer of Appium.