Mobile automation testing for React Native and Flutter: Maestro, Detox, Appium and device farms compared
Mobile automation testing for React Native and Flutter: Maestro, Detox and Appium compared, with device farm prices and a worked monthly bill.
By Rokibul Hasan8 min read
- Testing
- Mobile apps

An app can work perfectly on the phone it was built on and still fail at sign-in after a routine update. Mobile automation testing is how you find out before your reviews do: a tool drives the compiled app on a simulator or device, taps through your main flows and reports what failed.
This guide is for founders and product owners with a React Native or Flutter app, or planning one. It compares Maestro, Detox, Appium and Flutter's own tools, explains when real devices matter, and works out what a modest setup costs each month.
I build iOS and Android apps in both frameworks, and my React Native vs Flutter guide covers choosing between them. The test tools below are compared from their own documentation as of November 2026, so read this as a buyer's guide and not as a report from my own test lab.
Mobile automation testing tools at a glance
| Tool | Works with | Tests written in | Know before choosing |
|---|---|---|---|
| Maestro | React Native, Flutter, native iOS and Android, web | YAML flows | Free and open source, but physical iOS devices are not yet supported |
| Detox | React Native only | JavaScript | Waits for the app to settle; no physical iPhones |
| Appium | Most stacks, through drivers | JavaScript, Java, Python and others | Widest reach, most setup |
| integration_test and Patrol | Flutter only | Dart | Patrol adds the native dialogs integration_test leaves out |
All of them can cover a sign-in or checkout flow. The real choice is who will write and maintain the tests, and which devices you need to reach.
Why mobile automation testing costs more than web testing
If you have read my guide to Playwright automation testing, its method for ranking flows applies here unchanged. The difference is the price of each test:
- The app must be built first. Every run starts from a compiled build, and iOS builds need a Mac.
- There are two platforms. A flow that passes on Android can fail on iOS.
- The phone gets in the way. Permission prompts, notifications and the keyboard all sit outside your app.
- Tests are slower and less stable. React Native's testing docs say end-to-end tests take longer to write, run more slowly and are more prone to flakiness.
Both frameworks give the same advice on scope. React Native's docs say to cover "the vital parts of your app", naming authentication, core functionality and payments. Flutter's docs describe a well-tested app as having many unit and widget tests, plus enough integration tests for the important use cases. So plan for a handful of flows, not a copy of your whole app.
React Native: Maestro first, Detox when timing bites
Maestro tests the built app from the outside, through the accessibility layer, so you add no package and change no JavaScript. You give elements a testID, which Maestro reads as an id, and that holds up when labels change or the app is translated. A flow is a short text file:
appId: com.example.shop
---
- launchApp:
clearState: true
- tapOn:
id: "email_input"
- inputText: "test@example.com"
- tapOn: "Send code"
- assertVisible: "Check your email"
A product manager can read that and tell you whether it matches the real journey, which is a large part of its appeal. Expo's CI workflows can run Maestro jobs too, though its pricing page excludes them from the Free plan.
Detox works from the inside. It calls itself gray box: it monitors asynchronous work in your app and acts when the app is ready, where an outside tool can only watch the screen. That makes it attractive for busy screens where timing causes false failures. The price is a heavier setup, with changes to Android build files and a native test class, and Expo projects follow a separate guide.
Check the version fit before you commit. Detox's README lists official compatibility for React Native 0.77 to 0.84 and says newer versions might work but have not been thoroughly tested. The latest React Native on npm is 0.88.1 at the time of writing, so a current app should try Detox on a branch first.
A reasonable default is Maestro for the first flows, moving to Detox if timing failures become the main complaint and JavaScript developers will own the tests.
Flutter: choose by who writes the tests
Flutter's own integration_test package uses the same Dart APIs as widget tests, runs on a device or emulator, and can run on Firebase Test Lab. Flutter developers can use it with little new to learn.
Patrol, from LeanCode, builds on it. It says it overcomes the limits of integration_test by handling native interactions: permission dialogs, notifications, WebViews and device settings, all in Dart. If your app asks for location or sends push notifications, that matters.
Maestro works from outside again, through Flutter's Semantics tree, with no change to pubspec.yaml. Widgets that show text can be targeted by default, while icons need a label. Maestro's Flutter docs warn that Flutter Keys are invisible to it and recommend a Semantics identifier, available from Flutter 3.19. There is a side benefit: labels added for tests come from the same semantics layer that assistive technology reads, so that work can improve accessibility too.
So if Flutter developers will write the tests, start with integration_test or Patrol. If a QA person or product manager will write them, Maestro is the easier route.
Appium: for mixed stacks and QA teams
Appium describes itself in four parts: a core, drivers for each platform, clients for each programming language, and plugins. You install what you need, which is why it reaches so far and takes longer to set up. Its official drivers cover UiAutomator2, Espresso and XCUITest among others. The two Flutter drivers on its list sit outside that official set and lean on community support, so check their activity first.
Appium suits a company with QA engineers who already work in Java or Python, a mix of native and cross-platform apps, or a device cloud contract. For one small app with no QA team, it is more machinery than the job needs.
Simulators, real devices and device farms
Simulators and emulators are cheap and quick to start, so they suit frequent runs. Real devices show what simulators cannot: true performance, the camera, low memory and manufacturer quirks. Most small apps need emulator runs often and a real-device pass before a release.
Device farms rent you those phones. Prices below are from each provider's page in November 2026.
| Service | What it runs | Price |
|---|---|---|
| Firebase Test Lab | Instrumentation, Robo, Game Loop, XCTest | No-cost plan: 10 virtual and 5 physical test runs a day. Pay-as-you-go: 60 virtual and 30 physical minutes free daily, then $1 and $5 per device hour |
| AWS Device Farm | Appium, instrumentation, XCTest | $0.17 per device minute, or $250 per unmetered slot a month |
| Maestro Cloud | Maestro flows, with iOS on simulators | $250 per device a month |
| BrowserStack App Automate | Appium, plus Maestro on real iOS and Android devices | See BrowserStack's pricing page for current plans |
Your tool narrows this list. Neither Test Lab nor Device Farm names Maestro among its frameworks, while BrowserStack's docs describe running Maestro on real iPhones. If you need that combination, confirm it in a trial before you write many flows.
What mobile automation testing costs: a worked bill
These numbers are assumptions to show the arithmetic, not measurements. Suppose you have 12 flows taking 18 minutes in total, and an iOS build that takes 15 minutes.
- iOS on a GitHub-hosted Mac. GitHub charges $0.062 a minute, so a 33-minute run costs about $2.05. Eight runs a month come to about $16.37.
- Real devices before release. Running the 18-minute suite on three phones on Device Farm uses 54 device minutes, or $9.18. Two releases a month come to $18.36.
That is around $35 a month, against $250 for one Maestro Cloud device. The cloud service may still be worth it for the convenience, but compute is the small number either way. The larger cost is people: keeping flows current as screens change, and looking into every failure.
Two habits keep both down. Run the slow suite on release candidates, not on every push. And keep Linux jobs, such as unit tests, away from Mac runners, which cost about ten times as much per minute. My guide to deployment automation explains how that allowance works.
What to keep manual
Automation covers repetition. Some checks still need a person holding a phone:
- The first-run experience on a fresh install, including permission prompts.
- Apple Pay or Google Pay sheets and anything else owned by the operating system.
- Push notifications arriving and opening the right screen.
- VoiceOver and TalkBack on your main flows.
- Anything that has to feel right: scrolling, animation, how long a screen takes to appear.
A short written checklist run before each store submission covers these. For a first release you may need nothing else, which is the logic of my MVP development guide: prove people want the app before you pay to protect every screen.
FAQ
Can one test suite cover both iOS and Android?
Largely, yes, if you use a tool that tests from outside the app or runs on both platforms. Maestro flows and Appium scripts can run on both, and Detox covers both for React Native. You may still need small platform branches for permission prompts or system dialogs. Each platform also needs its own build, and iOS builds need a Mac, so one suite does not mean one run.
Do I need real devices for mobile app testing?
Not for every run. Simulators and emulators are cheaper and quicker, so they suit frequent checks of your main flows. Real devices matter before a release, because they show true performance, camera behaviour, memory limits and manufacturer quirks that simulators miss. A device farm such as AWS Device Farm or Firebase Test Lab lets you rent phones by the minute, so a small app does not need its own shelf of hardware.
Is Detox better than Maestro for React Native?
Neither is better in every case. Detox works inside the app and watches its asynchronous work, which can reduce timing failures, but it needs more setup and only supports React Native. Maestro tests the compiled app from outside using simple YAML, so it is faster to start and easier for non-developers to read. Many small teams can start with Maestro, and Detox makes more sense once timing problems dominate.
If you have an app and want its key flows protected, send me a short brief: the framework, your main user journeys, how you release today and which devices your users have. Adding automated tests to an app is custom work quoted from a brief, and you can start from the mobile app plan, read about my mobile app development work, or compare my mobile app plans.


