The minimum mobile launch test
Before launch, take at least two real phones and complete the same shopping path on each: open the homepage, use the menu, enter a category, inspect a product, add it to the cart, edit the cart, and place a real order that you then refund. Repeat the path with an invalid field and a canceled payment. A pass means a shopper can understand and complete every step without accidental taps, hidden information, clipped content, or a dead end. Record each failure against a device and a page, and fix it before you launch, starting with anything that blocks a purchase.
A resized desktop browser catches obvious width problems. It won’t show the on-screen keyboard covering a field, the browser bar hiding the bottom of the screen, a gallery that swallows the page’s scroll gesture, or whether a button really sits under a thumb. Those failures cost mobile orders, so the test needs real phones. It covers launch, not a full accessibility or performance audit.
Choose a small device matrix
Don’t try to cover every phone. Choose devices that expose meaningful differences and that you can physically test. If your analytics already contain reliable audience data, use it to refine the matrix; don’t invent a “typical customer” device.
| Test slot | Real device to choose | Connection and settings | Why it earns a place | Path to run | Result |
|---|---|---|---|---|---|
| Phone A | A smaller or older phone available to the team | Wi-Fi, normal text size | Reveals narrow-layout, reach, and wrapping problems | Homepage → category → product → cart → checkout | Pass / Fail |
| Phone B | A larger or newer phone on the other major mobile OS | Wi-Fi, normal text size | Adds another browser engine, keyboard, and screen shape | Same controlled path | Pass / Fail |
| Readability repeat | Either phone | Increase text size or browser zoom; test up to 200% where supported | Exposes clipping, overlap, and lost controls | Menu, product details, cart, form errors | Pass / Fail |
| Constrained repeat | Either phone | Slower or less stable connection available to you | Reveals unclear waiting states and image-loading problems | Homepage → product → cart | Pass / Fail |
Record device model, operating-system version, browser, test time, product used, and result. For each failure, note what the tester meant to do, what they tapped first, where they stopped, and what the screen showed. “Works” is too vague to fix anything; “after opening the menu, every category name is visible without sideways scrolling” is a result. Screenshots or short screen recordings help whoever fixes the failure reproduce it, but never include real customer or payment data.
Don’t fix anything during the first pass. Finish the whole path, then sort the failures: those that block a purchase, those that cause mistakes, and those that only hurt readability. A spacing tweak should never jump ahead of a covered payment button.
1. Start with navigation and hierarchy
On each phone, land on the homepage without prior context. Within a few seconds, can you tell what the store sells and find the main route into the catalog? The logo, menu, and cart should be recognizable without dominating the first screen. Opening the menu must not hide labels, cut off the last items, or leave the page scrolling behind it.
Run five tasks from the e-commerce navigation design guide: find a main category, reach a named product, return to the category, open the cart, and return to shopping. Labels should describe destinations rather than rely on “Explore” or unfamiliar brand language.
Then check the vertical order. On a phone, the homepage becomes one long column, and the order of that column is the design. The offer and the main shopping route should come before secondary stories, social content, or newsletter prompts. Sticky controls must not cover product names, prices, errors, or the checkout action.
2. Test taps, text, and visible focus
Use a thumb, not a precision pointer. Try the menu, close control, product cards, quantity controls, remove action, form fields, and checkout button. Count an accidental neighboring action as a failure. WCAG 2.2’s minimum target-size criterion specifies at least 24 by 24 CSS pixels, with defined exceptions including sufficient spacing. Treat that as the floor: quantity minus, plus, and remove sitting side by side need more room than the minimum.
Read every label without zooming first. Body text, prices, helper copy, and policy links should not require squinting; headings should stand out without consuming most of a small screen. Next, enlarge text. WCAG 2.2 requires text to resize to 200% without loss of content or functionality, and its minimum contrast criterion uses 4.5:1 for ordinary text and 3:1 for large text, with stated exceptions (WCAG 2.2, section 1.4). On the smaller phone, ordinary pages should not scroll sideways: the reflow criterion sets 320 CSS pixels as the width at which content should work without scrolling in two directions, except for content that needs a two-dimensional layout.
Also navigate with the controls available on the device and, where practical, a paired keyboard or screen reader. Interactive elements need a visible state and an understandable name. Color alone should not communicate sale, selection, availability, or error.
3. Inspect categories, cards, and images
Open a busy category and the smallest one. Product cards should keep image, product name, price, and any truthful sale state together. Long names may wrap, but must not collide with neighboring cards or push prices into ambiguity. Cards in one row should remain easy to compare. Check the complete card behavior against the category page design guide.
Tap the image, text, and intended action separately. A card must not contain surprising overlapping targets. Test a long title, a wide price, a sold-out item (Setka keeps sold-out products visible), and the products with the tallest and widest source images.
On the product page, confirm that the primary image is sharp enough to evaluate but does not push essential information far below the fold. Change orientation once. Crops must not remove the part of the product needed to understand it, and decorative overlays must not cover it. Swipe through the gallery and check that the page still scrolls normally. Responsive images let a browser select a suitable source for the display instead of always transferring an oversized file; web.dev explains the mechanism. If a crop fails because of the photo itself, the product images and brand assets checklist covers what to shoot.
4. Exercise every important cart state
Add a known test product, then inspect the cart without relying on memory. The image, name, quantity, unit or line price, subtotal, and next action should be clear. Change quantity, remove the item, and create an empty cart. Confirm that the subtotal changes correctly and that the empty state offers a useful route back.
Test the longest realistic product name and a discount state if discounts are configured. Shipping and tax wording must match the actual rules and must not imply that a displayed subtotal is the final charge when it is not. If a validation message appears, it should stay near the relevant control and explain what to do next. The shopping cart UX guide lists every cart state worth testing.
5. Complete checkout with and without errors
Run this on the published store with your own card; you will refund the order afterward. Check each form field while the mobile keyboard is open. The active field, its label, helper text, and next action should remain visible; the keyboard must not permanently cover the submit button or an error. A label must stay visible after the shopper starts typing, because placeholder text that disappears is not an instruction; WCAG requires labels or instructions for fields that take input. The right keyboard type for phone, email, and postal code makes entry easier, but it never replaces a clear label and format hint.
Submit an empty required field, malformed email, incomplete address, and any supported invalid discount or payment state. A useful error names the problem in text, appears near the field or failed step, and preserves valid information already entered; a red outline alone doesn’t say what went wrong. WCAG’s error identification criterion asks that an automatically detected error identify the item and describe it in text. Focus or the viewport should move to the error when needed. After correction, the shopper should be able to continue without restarting checkout.
Finish one successful order, verify the confirmation state, and refund it from the order. Then follow the broader online store launch checklist for payment, shipping, tax, domain, and order checks outside this mobile-focused test.
6. Observe loading and interruption
Don’t award a pass because a page eventually appears. On the constrained repeat, watch what shoppers see while the homepage, category, product imagery, cart update, and checkout transition load. The interface should acknowledge the action, avoid duplicate submissions, and not shift the intended tap target beneath a finger. Text and essential actions should not wait for decorative media. An image’s space should be reserved before the image arrives, so the layout doesn’t jump: web.dev recommends giving images dimensions and lazy-loading only images outside the first view.
Interrupt the path once: switch apps and return, rotate the phone, or briefly lose connectivity. Check whether the cart and completed form fields survive. If a request fails, the message should distinguish waiting from failure and offer a safe retry. Record “slow,” “blank,” “jumped,” or “submitted twice” as observable symptoms; a performance specialist can then measure and diagnose them.
Pass-or-fail checklist
Mark Pass only after observing the item on both primary phones. Use N/A only when the feature or state is genuinely absent, and write why.
| Check | Pass condition | Phone A | Phone B | Owner / fix |
|---|---|---|---|---|
| First screen | Offer and primary shopping route are clear | Pass / Fail | Pass / Fail | |
| Menu and cart | Open, close, navigate, and return without a trap | Pass / Fail | Pass / Fail | |
| Tap targets | No accidental adjacent action; size/spacing reviewed | Pass / Fail | Pass / Fail | |
| Text and zoom | Labels remain readable; enlarged text does not hide function | Pass / Fail | Pass / Fail | |
| Narrow width | No sideways scrolling on ordinary pages | Pass / Fail | Pass / Fail | |
| Hierarchy | Products and main routes precede secondary content | Pass / Fail | Pass / Fail | |
| Product cards | Image, name, price, and state stay together | Pass / Fail | Pass / Fail | |
| Product images | Useful crop, orientation behavior, gallery scroll, and loading state | Pass / Fail | Pass / Fail | |
| Cart states | Add, edit, remove, empty, subtotal, and next action work | Pass / Fail | Pass / Fail | |
| Checkout fields | Visible labels, keyboard, values, and submit action remain usable | Pass / Fail | Pass / Fail | |
| Errors | Message identifies the issue in text, preserves data, and enables recovery | Pass / Fail | Pass / Fail | |
| Loading | Actions receive feedback; no duplicate submit or layout jump | Pass / Fail | Pass / Fail | |
| Interruption | Cart and entered fields survive an app switch, rotation, or brief loss of connection | Pass / Fail | Pass / Fail | |
| Basic accessibility | Names, focus, contrast, non-color cues, and text resize checked | Pass / Fail | Pass / Fail | |
| Successful order | A real order reaches the expected confirmation and is refunded | Pass / Fail | Pass / Fail |
Fixing what fails in a Setka store
Setka is our product, and it changes what a failed check costs you. In a theme-based store, a fix the theme’s settings don’t cover means editing theme code or paying someone who can. In Setka, the storefront is built into the platform: from your brief and catalog, Setka generates the homepage, category and product pages, navigation, and cart, with their mobile layouts. When a check fails, you open the page, describe what should change and where (“on small phones, keep the add-to-cart button clear of the bottom bar”), and preview the next version. You can edit exact wording directly. Every change saves a version of the whole storefront, so if a fix makes something else worse, you can return to the version that passed.
Checkout and orders run in the same platform, so the path you test runs from the first screen to the paid order without a plugin in between. Setka also optimizes images; this test shows you what loads and when, and diagnosing speed still needs a separate measurement. There is no payment test mode yet, so the order step works as this checklist already describes: publish, place a real order from your phone, refund it from the Setka order, then launch.
After every round of fixes, rerun the whole path on both phones, not only the screen you changed.
Create your store in Setka, open the preview on two real phones, and run this checklist before you launch.