---
title: Emulators, Simulators and Real Devices | TestingBot
description: The first decision in mobile app testing is where a test runs. There
  are three kinds of target, and they are not interchangeable. Each one is right for
  some…
source_url:
  html: https://testingbot.com/resources/courses/mobile-app-testing/emulators-simulators-and-real-devices
  md: https://testingbot.com/resources/courses/mobile-app-testing/emulators-simulators-and-real-devices.md
---

Course

[Mobile App Testing: From First Test to CI](https://testingbot.com/resources/courses/mobile-app-testing)

Chapter 2 of 10

1. [1 Mobile App Testing: What Makes It Different](https://testingbot.com/resources/courses/mobile-app-testing)
2. [2 Emulators, Simulators and Real Devices](https://testingbot.com/resources/courses/mobile-app-testing/emulators-simulators-and-real-devices)
3. [3 Choosing a Framework: Appium, Espresso, XCUITest, Maestro](https://testingbot.com/resources/courses/mobile-app-testing/choosing-a-framework)
4. [4 Uploading and Managing App Builds](https://testingbot.com/resources/courses/mobile-app-testing/app-builds-and-uploads)
5. [5 Your First Appium Test on a Real Device](https://testingbot.com/resources/courses/mobile-app-testing/first-appium-test)
6. [6 Your First Maestro Flow on TestingBot](https://testingbot.com/resources/courses/mobile-app-testing/first-maestro-flow)
7. [7 Running Espresso and XCUITest Suites in the Cloud](https://testingbot.com/resources/courses/mobile-app-testing/espresso-and-xcuitest)
8. [8 Device Matrix, Parallel Runs and CI](https://testingbot.com/resources/courses/mobile-app-testing/device-matrix-parallel-ci)
9. [9 Debugging Failed Mobile Test Runs](https://testingbot.com/resources/courses/mobile-app-testing/debugging-failed-runs)
10. [10 Knowledge Check](https://testingbot.com/resources/courses/mobile-app-testing/knowledge-check)

[Exit course](https://testingbot.com/resources/courses)

 Chapter 2 of 10 Beginner 5 min read 2 quick checks Updated Nov 2026 

# Emulators, Simulators and Real Devices
On this page
1. [Android emulators](https://testingbot.com#android-emulators)
2. [iOS simulators](https://testingbot.com#ios-simulators)
3. [Real devices](https://testingbot.com#real-devices)
4. [Which one, when](https://testingbot.com#which-one-when)
5. [On TestingBot](https://testingbot.com#on-testingbot)

The first decision in mobile app testing is where a test runs. There are three kinds of target, and they are not interchangeable. Each one is right for some tests and misleading for others.

## Android emulators[#](https://testingbot.com#android-emulators)

An Android emulator runs a full Android system image in a virtual machine. It boots the real OS, with the real framework code, so your app behaves much as it does on a phone. What it does not have is a manufacturer: no Samsung skin, no vendor battery saver, no real camera, modem or GPS chip. Sensors and location are simulated.

Emulators are fast to create, reset to a clean state on every boot, and cheap to run many of in parallel. They are the right default for functional UI tests early in the pipeline: does the login screen accept a valid password, does the basket total update.

## iOS simulators[#](https://testingbot.com#ios-simulators)

The iOS Simulator is a different thing. It does not emulate an iPhone's ARM hardware and does not run the iOS kernel; it runs an iOS-flavoured runtime directly on the Mac. That makes it quick, and it is why simulator builds are a separate artefact: an app built for the simulator (an `.app`, often zipped) cannot be installed on a physical iPhone, and a device build (an `.ipa`) cannot be installed on the simulator.

Simulators miss things that matter on real iPhones: push notifications can be simulated but do not arrive through Apple's push service, there is no real camera, performance and memory pressure are the Mac's, not the phone's, and code signing and entitlements are barely exercised.

Your CI produces `MyApp.app` for the iOS Simulator. A colleague wants to run the same build on physical iPhones in the cloud. What do they need?

 Nothing; zip the `.app` and upload it with `realDevice` set A separate signed `.ipa` built for devices To rename the file to `MyApp.ipa`

Simulator builds are compiled for the simulator runtime and are not signed for hardware, so they cannot be installed on a phone. A device build, exported as a signed `.ipa`, is a different artefact, not a different file name.

## Real devices[#](https://testingbot.com#real-devices)

A real device is the only target that runs the exact combination your user has: the vendor's Android skin, the real GPU, a real cellular modem, real biometric hardware, real thermal throttling. Bugs that only show up here include:

- vendor-specific behaviour: aggressive battery optimisation, a different keyboard, a custom permission dialog;
- rendering and performance: janky scrolling, a WebView that renders differently, the app being killed in the background on a low-memory phone;
- hardware features: camera capture, NFC, fingerprint and face unlock, GPS in motion;
- anything that depends on signing: push notifications, app extensions, keychain sharing on iOS.

The cost is speed and availability. A physical device has to be cleaned after each session, and a specific model can be busy when you ask for it, so sessions can wait in a queue. The [real device testing](https://testingbot.com/real-device-testing) page describes what TestingBot's device cloud offers.

## Which one, when[#](https://testingbot.com#which-one-when)

A rule of thumb that holds up for most teams:

| Question you are asking | Good target |
| --- | --- |
| Does this pull request break a core flow? | Emulators and simulators, on every commit |
| Does the layout survive small and large screens? | Emulators and simulators with different sizes, plus one or two real devices |
| Does it work on the phones our users actually have? | Real devices, chosen from your analytics, nightly or before release |
| Do camera, biometrics, push or payments work? | Real devices only |
| Is it fast and smooth enough? | Real devices only; emulator performance tells you about the host machine |

The usual shape is a pyramid on its side: lots of fast virtual-device runs early, fewer real-device runs later. Emulators and simulators answer "is the logic right", real devices answer "does it work for users".

A bug report says the app freezes when users scan a QR code with the camera on a mid-range Samsung phone. Where do you reproduce it first?

 On a real Samsung device, ideally the same model and Android version On an Android emulator with the same Android version On the iOS Simulator, since it is faster In a unit test of the QR decoder

The camera, the vendor's Android build and mid-range hardware are all part of the symptom, and none of them exists on an emulator. A unit test of the decoder is worth adding once you know the cause, but it cannot reproduce a device freeze.

## On TestingBot[#](https://testingbot.com#on-testingbot)

The same test code can target either kind of device; only the capabilities or CLI flags change:

- **Appium** : `'tb:options': { realDevice: true }` asks for a physical device; without it you get an emulator or simulator. Chapter 4 runs both.
- **Maestro and Espresso** (TestingBot CLI): emulators by default, `--real-device` for physical devices. For Maestro, an `.ipa` selects real iPhones automatically.
- **XCUITest** : the documentation describes runs with a signed `.ipa` and a test `.zip` on physical iPhones and iPads.

`npx @testingbot/cli devices --framework espresso` (or `maestro`, `xcuitest`) lists the device names and OS versions you can request; add `--real` for physical devices and their current availability. The [devices page](https://testingbot.com/support/app-automate/devices) shows the same list in the browser.

One habit saves a lot of confusion later: record in every test's name or build which kind of device it ran on. "Passed on an emulator" and "passed on a real device" are different statements, and this course says which one it means for every run it reports.

[Previous · Chapter 1 Mobile App Testing: What Makes It Different](https://testingbot.com/resources/courses/mobile-app-testing) [Next · Chapter 3 Choosing a Framework: Appium, Espresso, XCUITest, Maestro](https://testingbot.com/resources/courses/mobile-app-testing/choosing-a-framework)

On this page

1. [Android emulators](https://testingbot.com#android-emulators)
2. [iOS simulators](https://testingbot.com#ios-simulators)
3. [Real devices](https://testingbot.com#real-devices)
4. [Which one, when](https://testingbot.com#which-one-when)
5. [On TestingBot](https://testingbot.com#on-testingbot)

Certification

Earn the free, resume-worthy TestingBot Mobile App Testing Certification for this course.

[How it works](https://testingbot.com/resources/courses/mobile-app-testing/certification)
