Blog / Mobile App Manual Testing: How to Run Sessions That Find What Scripts Miss
Guide

Mobile App Manual Testing: How to Run Sessions That Find What Scripts Miss

Phone bugs hide in calls, signal drops and upgrades. Run mobile app manual testing in timed sessions and log bugs a developer can reproduce on iOS and Android.

You are halfway through checkout when a call comes in. After you answer it and return to the app, the cart holds the same item twice. No script was waiting for that call.

A timed session with a goal catches that bug, and notes taken as you go turn it into a report a developer can reproduce on the first try. Here is how to run that session on a phone, whether you test full time or test your own builds between commits.

What you’ll learn

  • What a person catches on a phone that a script does not
  • How to run a timed session with a charter and a debrief
  • Which phone settings and states to vary on purpose
  • What to write down while you test
  • How to log a bug a developer can reproduce
  • Which mobile test automation fits a check once it repeats

What Does Manual Testing Catch on a Phone That Scripts Miss?

Mobile app manual testing means a person runs the app by hand on a phone, with no script, and judges what happens. A person catches what depends on the phone around the app. A script follows the path it was given, while a phone keeps changing the path.

AreaEasy to miss in a scriptHow to provoke it by hand
InterruptionsA fixed path with no outside eventsTake a call, lock the screen, or open another app mid-flow
GesturesExact taps at an even paceSwipe fast and slow, start at the screen edge, long-press
System promptsThe prompt exactly as it looked last runDeny, allow once, then revoke in Settings
ScreensOne device size and one text sizeLargest text, dark mode, a small phone, landscape
NetworkA steady connectionSwitch Wi-Fi to cellular mid-request, then go offline
Install stateA clean install every timeUpgrade over an older build that holds real data

Each row also covers things a script cannot judge, such as a label clipped by large text or a button too close to the edge to hit with a thumb. The checks pass while the screen is wrong, and a person sees it at a glance.

How Do You Run a Manual Mobile Testing Session?

A session turns wandering around the app into work you can plan, review, and repeat. James and Jon Bach built session-based test management at Hewlett-Packard to manage testing by what testers do instead of by the documents they produce. On a phone, the same idea gives each hour of exploratory testing a goal, a clock, and a record.

A Session in One Line

A session is one charter, one clock, running notes, and a short debrief.

Run a Session in Five Steps

  1. Write the charter: One sentence naming the area, the risk, and what you want to learn. A charter that fits on a line keeps the session from drifting.
  2. Write down the starting state: Do it before the first tap. A bug you cannot trace back to a state is a bug you cannot reproduce.
  3. Start the clock: An hour is a workable length. When it ends, stop, even if the area feels unfinished, and let the notes say what is left.
  4. Vary one thing at a time: Change the state, the input, or the interruption, but never all three at once, so a failure points to its cause.
  5. Debrief: Spend ten minutes with a developer or teammate straight afterward. Cover the bugs found, the areas not covered, and the next charter.

Charters That Fit a Phone

  • Interruptions: Explore checkout with calls, lock screens, and app switches to learn whether the order survives each one.
  • First run: Explore a fresh install with permissions denied to learn whether a new user can reach the home screen.
  • Upgrade: Explore an upgrade over an older build to learn whether saved data and settings survive.

What Should You Vary on Purpose During a Session?

A phone changes state all day, so a session needs deliberate variation. These are the dials worth turning, and most of the tools are already on the phone.

  • Interruptions: Take a call, let a notification land, lock the screen and wake it, then switch apps and return. The question is always whether the app comes back where the user left it.
  • Permissions: Deny a permission prompt, allow it once, then revoke it in Settings with the app open.
  • Network: Move from Wi-Fi to cellular mid-request, go offline, and come back. Watch the recovery closely, and simulate the network conditions you cannot get at a desk.
  • App state: Send the app to the background and return after a while. Android’s Developer options include Don’t keep activities, which destroys each activity as soon as you leave it, so every return tests whether the app restores its screen.
  • Gestures: Swipe fast and slow, start from the edge, long-press, and rotate. Developer options also offer Show taps, a circle under each touch, and Pointer Location, which draws the path of the gesture and tracks its coordinates.
  • Install state: Test a fresh install, then an upgrade over the previous build with real data in place.
  • Display: Try the largest text size, dark mode, a small screen, and landscape.

Hand Off the Flows You Repeat

Bring a flow you retest every release to a demo.

What Should You Write Down While You Test?

Notes taken as you go are what turn a strange moment into a reproducible bug, because memory drops the step that mattered. Keep one running log per session and stamp each line with the clock time so it lines up with a recording.

  • Path: What you did, in order, one action per line.
  • Bug: What looked wrong, plus a note that you captured evidence.
  • Question: Anything odd that may not be a bug yet.
  • Setup change: Anything you changed mid-session, such as switching on airplane mode.
  • Not covered: What you skipped, so the debrief knows.

Record the screen for the whole session when you can. An iPhone’s Control Center has a Record button that starts after a three-second countdown, and the Screen Recording button stops it, as Apple’s page on screen recording explains. On Android, switch on Show taps first so the video shows where each finger landed.

How Do You Log a Bug a Developer Can Reproduce?

A phone bug report has to carry the state of the phone, because the same steps can pass on one device and fail on another. Write each field so a developer who has never held your device can set up the same conditions.

FieldWhat to writeWhy a phone needs it
BuildVersion and build numberThe fix targets the build you tested
Device and OSModel and OS versionDevices and OS versions behave differently
Starting stateFresh install or upgrade, signed in or out, permissions granted or deniedThe same steps act differently from another state
NetworkWi-Fi, cellular, or offline, and any switch mid-flowA switch can fail where a steady link works
StepsOne action per line, from launchA shortcut skips the state that mattered
Expected and actualWhat should happen and what didIt separates a bug from a surprise
FrequencyEvery time, sometimes, or onceIt tells the developer how hard to chase it
EvidenceScreen recording and a screenshotIt shows the moment words leave out

For the title, give the symptom and the event that preceded it, such as “Cart shows the item twice after returning from a call”. On Android, Developer options also offers Take bug report, which copies the device’s log files so you can share them. The Android team’s page on the bug report says it holds device logs and stack traces, which gives the developer something to read besides your description.

When the Bug Will Not Repeat

Go back to the notes and the recording, rebuild the starting state, and rerun the path one change at a time. Look at what the phone did just before the failure, such as a call, a network switch, or a return from the background, and repeat that event first. Write down every attempt, including the ones that pass, since a pattern only shows itself across the tries.

Turn a Bug You Found by Hand Into a Check That Repeats

Finding a bug takes one session, while rerunning the same checks every release is where manual hours drain, well past the point where manual testing stops scaling. Split the work by whether a check needs judgment.

  • Keep by hand: Anything that needs judgment, such as whether a flow feels right, whether a screen looks wrong, and where a new feature is likely to break.
  • Hand off: Steps you have run the same way on several releases, where the result is a plain pass or fail.

Which Mobile App Test Automation Fits the Check?

A check that is ready to hand off has two routes: a scripted framework, or a description of the flow. Scripted frameworks run fast and precisely, and someone on your team writes and maintains the code. Each platform has a native option, and one tool spans both.

ToolPlatformFits a check that
EspressoAndroidStays inside your app. Google’s docs say Espresso waits to act until its synchronization conditions are met, so the script needs fewer sleeps.
UI AutomatorAndroidLeaves your app for a system app, such as the Settings screen where you revoke a permission. It tests from outside the app’s process.
XCUITestiOSDrives an iOS app’s screens. UI tests are part of Apple’s XCTest framework for Xcode projects.
AppiumiOS and AndroidHas to run on both platforms from one suite. Appium is open source and covers many app platforms, mobile among them.

Every row is a script, so each one carries upkeep when screens change. The mobile test automation guide covers how to pick among them, and mobile regression testing covers why selectors break across devices.

Or Describe the Flow to Pie

Hand Pie the flow behind that bug, and our agentic testing platform turns it into a check you can rerun every release while the tester moves on to the next charter.

  • Describe the flow: Tell Pie Chat what you just did in plain English. It explores the flow and drafts a test case with an Objective, What Pie will do, and What should be verified. You review the draft before anything runs.
  • Skip the scripting: No scripts to write, no locators to break.
  • Pick the devices: Name the iPhone, iPad or Android device and the OS version. Pie runs the check on simulators and emulators, with real devices available on demand.
Pie Chat draft card with Objective, What Pie will do, and What should be verified
A flow described in Chat comes back as a draft to review.

Aim Human Hours at the Surprises

A phone gives a tester more surprises than any pipeline can script. There is the call, the dropped signal, and the old build carrying new data. A session with a charter, a clock, and honest notes turns each one into a bug a developer can fix.

The checks that stop surprising you belong somewhere cheaper. The rest are the reason a person holds the phone.

Keep Checking What You Found

See a tested flow turn into a check. Pie Chat drafts it for review.

Frequently Asked Questions

About an hour is a workable default, long enough to go deep on one charter and short enough that attention and notes stay sharp. When the clock ends, stop, write down what is left uncovered, and start a new session with a new charter.
A developer needs the build, the device and OS version, and the state the app started in. Add the steps from launch, what you expected against what happened, and a screen recording. On Android, attach the bug report from Developer options so the device logs travel with it.
Let your own analytics decide. Rank devices by sessions and crashes, test the top of that list, and add one mid-range Android phone. Add another model only when real usage shows a gap, because a device nobody opens adds cost and no coverage.
For many functional checks, such as flows, forms, navigation and state changes, yes. Anything that depends on hardware, such as sensors, the camera or a manufacturer's battery handling, needs a physical phone, so do the release pass on one.
Automate a check once you have run the same steps the same way on several releases and the result is a plain pass or fail. Keep anything that needs judgment, such as whether a screen feels right, in a session with a person.
Rebuild the starting state from your notes, then repeat the event that came just before the failure, such as a call, a network switch or a return from the background. Change one variable per attempt and record every try so the pattern shows itself.
Developers should test their own builds by hand before review. A short session on the changed screen catches broken states early, and a tester adds fresh eyes and wider device coverage. Both can work from the same charter and bug report format.
Espresso and UI Automator cover Android, XCUITest covers iOS, and Appium drives both platforms from one suite. All four run scripts your team writes and maintains. Pie takes a plain-English description of the flow instead, so nobody scripts it.
No, Pie adds to the people who test by hand. Describe a flow you tested in a session to Pie Chat, review the draft, and Pie repeats it on iOS simulators and Android emulators. Judgment calls stay with your testers.
Jinoo Jain
Jinoo Jain
CPO & Co-founder at Pie

Spent a decade in B2B SaaS sales before building Pie. Now obsessed with helping engineering teams ship without the fear of breaking things. LinkedIn →