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.

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
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.