Blog / Mobile End-to-End Testing Shrinks to the Happy Path
Insights

Mobile End-to-End Testing Shrinks to the Happy Path

On mobile, "end-to-end" has quietly come to mean "end of the app." The tests that cross the OS boundary are the first ones teams skip when they flake.

A mobile end-to-end suite rarely gets deleted. It gets narrower. The flows that were supposed to prove the product works end to end slowly stop covering the parts that break, until “end-to-end” means the app launched and the happy path still clicks through on a warm emulator.

What decides a suite’s worth is which tests you keep once they start costing you. On mobile, end-to-end has come to mean end of the app, not end of the journey.

What you’ll learn

  • Why a genuine mobile E2E journey has to cross the OS boundary
  • How the highest-value flows become the first tests teams skip
  • How to tell coverage erosion from a deliberately lean pyramid
  • What changes which tests survive a weekly release cadence

When End-to-End Means End of the App

A real mobile journey does not stay inside your app. Signing in runs through Face ID. Paying runs through an OS payment sheet your code does not draw. Opening a notification resumes a deep link from outside the process. Each of those crosses the boundary between your app and the operating system, and none of them has an equivalent in web testing.

The standard advice is to keep end-to-end coverage scarce: reserve it for a few high-value journeys like login, checkout, and subscription, and push everything else down to unit and integration tests.

Good advice. The problem is what happens to it under a release schedule.

The Journeys That Cross the OS Boundary

Look at which journeys made the high-value list: login, checkout, subscription. On mobile, login often runs through biometrics, checkout goes through the OS payment sheet, and a subscription upgrade can bounce to the App Store or Play sheet and back. The highest-value gates sit on the OS boundary, so the tests that cover them are the hardest to keep green.

Checkout journey alternating between the app and the OS, crossing the boundary three times
Three OS hand-offs, and a test has to carry the journey across each one.

This is where a full picture of mobile app testing matters, because the risk is not spread evenly. A redesigned button on a settings screen is cheap to miss. A broken Face ID prompt on launch locks every user out. The expensive flows and the fragile flows are the same flows.

The mechanism underneath is simple. Mobile has no stable DOM. There is no reliable selector contract the way there is on the web, so a selector-based mobile test breaks on redesigns, layout reflows, and OS-level display changes that have nothing to do with the feature you shipped. The flows that cross the OS boundary flake the most, because they depend on the most state you do not control.

The Hardest Tests Get Skipped First

A test flakes. You have a release to ship. We usually see teams pick one of two options: sink the time into fixing the test, or comment it out and move on.

Fixing an OS-boundary test often means reproducing an emulator’s exact degraded state or an OS dialog’s exact timing, which can take longer than the feature did. Skipping it takes one line. Under deadline the one-liner wins, and a skipped test looks identical to a passing one on the dashboard.

Do that a few times and a pattern emerges that nobody chose. The tests you skip are never the cheap ones. They are the biometric login, the payment sheet, the deep-link resume, the permission-gated camera flow, the tests that were expensive precisely because they covered the OS boundary. Coverage does not shrink evenly. It erodes from the top-risk flows down, until what remains is the happy path on a clean emulator, which is the one configuration no real user is ever in.

This Is Erosion, Not a Leaner Pyramid

⚖️ The honest counter-argument

Keeping end-to-end tests scarce is textbook practice. Google made the case for a thin top layer in 2015, and the testing pyramid has said it since 2009. A suite that shrank, the argument goes, is a suite that got disciplined.

I agree with the scoping. Reserving end-to-end coverage for the journeys that carry the most revenue and retention risk is correct, and I am not arguing for a thousand brittle UI tests. What I am arguing about is which tests survive.

A deliberately lean pyramid keeps the highest-value journeys and drops the low-value ones. Attrition does the opposite. It keeps whatever is cheap to maintain and drops whatever is expensive, and on mobile the expensive tests are the high-value ones. You end up with a suite that looks disciplined, a tight set of green end-to-end tests, that is inverted underneath: it covers the flows that matter least to a user and skips the ones that would page you at 2 a.m.

The economics are about to tilt further. Google is shutting down Firebase Test Lab on September 30, 2027 and pointing teams to its Developer Device Platform, and the cost of running on device farms is in flux. When the OS-boundary tests also get more expensive to execute, the pressure to comment them out only grows.

What Keeps the Hard Journeys Covered

The usual prescription for this is discipline: a standing engineer to keep the suite green, a rule that nobody merges with tests skipped. Neither survives a weekly release cadence. The faster you ship, the more the maintenance tax compounds, and the first thing that gives is the hard test. Discipline is a tax you pay forever; attrition is what happens when you can no longer afford it.

To be fair, the tooling has moved. Today’s frameworks can automate the OS boundary: Appium, Espresso, and XCUITest can drive permission dialogs, and synchronization features like Maestro’s reduce flakiness. But they do not remove the underlying selector problem, so the maintenance cost and the attrition remain. Plenty of tools now offer scriptless or plain-English authoring, from Maestro Studio to Testsigma, mabl, and Drizz, and vision-based execution is a category with several vendors in it.

Maintenance cost is the lever. If a test is not bound to a selector or a hand-scripted OS dialog, a redesign or an OS update does not hand it back to an engineer. The OS-boundary flow that used to be the first casualty stops being the expensive one to keep. Change what a test costs to maintain and you change which tests survive the next deadline, which is the only version of “keep your E2E tests honest” that holds up under a real release schedule.

Where Pie Fits, and Where It Doesn’t

Pie is one of those vision-based tools. It tests native iOS and Android apps, and its agents identify each element by what is on the screen, the way a person does, with no CSS selector or XPath involved, so your team never writes or maintains a selector. You drop in a build and Pie’s discovery explores the app screen by screen. Fi runs its mobile releases this way, and the Fi case study shows what that changed in its release cycle.

Pie runs those tests on the iOS Simulator and the Android Emulator. One limit sits right on the OS boundary: Pie does not read live one-time codes from SMS or an authenticator app, so live OTP stays outside its scope.

Test the Journey, Not the App

End-to-end is a promise about coverage. On mobile that promise is only kept if the suite exercises the places where your app meets the operating system, because that is where real users live and where real releases break. Tests at that boundary disappear because they cost the most to keep, which makes them the rational thing to skip under deadline.

Keep the hard journeys off the selector treadmill and end-to-end can go back to meaning the end of the journey, not the end of the app.

Stop Skipping the Tests That Matter Most

Drop in your app and watch Pie's agents explore your iOS and Android flows, with no scripts to write.

Frequently Asked Questions

A mobile end-to-end test should follow a full user journey out of your app and into the operating system, through biometric login, an OS payment sheet, a push-notification deep link, or a permission dialog. A test that only taps through in-app screens on a clean emulator stops at the end of the app.
Scoping end-to-end coverage to high-value journeys like login, checkout, and subscription is sound advice. On mobile, those same journeys cross the OS boundary and cost the most to keep green, so 'scarce' tends to become 'only the cheap ones,' the opposite of what scoping intends.
Selector-based mobile tests break on redesigns and OS changes unrelated to the feature, and the tests that cross the OS boundary flake the most. Under a release deadline, teams either spend the time fixing a flaky test or comment it out, and the expensive OS-boundary ones tend to get commented out.
Yes. Appium, Espresso, and XCUITest can drive permission dialogs, and framework synchronization features like Maestro's reduce flakiness. The issue is not whether it is possible but what it costs to maintain, because selector-based tests still break when the UI or OS changes, and that maintenance cost is what drives the attrition.
Real devices are available on demand. Pie runs tests on the iOS Simulator and the Android Emulator, as the iPhone, iPad or Android device you pick, on the OS version you choose.
Vision-based tests identify elements by what they look like and do, the way a person would, instead of by CSS selectors, XPath, or accessibility IDs. Because no selector is written or maintained, a redesign or OS update that would break a selector-based test does not hand the test back to an engineer.
Dhaval Shreyas
Dhaval Shreyas
CEO & Co-founder at Pie

13 years building mobile infrastructure at Square, Facebook, and Instacart. Now building the QA platform he wished existed the whole time. LinkedIn →