This guide walks you through manually testing a mobile app on both iOS and Android. You’ll learn a structured approach to find bugs, verify functionality, and ensure a smooth user experience before release. No automated tools are required—just a device, a checklist, and a methodical mindset.
What You’ll Need
- A physical smartphone or tablet (iOS and/or Android) with the app installed. If possible, use a real device rather than an emulator for accurate hardware/network testing.
- A test plan or list of core features to cover. This can be as simple as a spreadsheet.
- Access to the app’s backend or API endpoints (for checking server responses).
- A note-taking tool (e.g., Notes, a bug tracking system) to record issues.
- Optional: A second device for cross-device testing, a Wi-Fi connection, and a mobile data plan.
Step-by-Step
- Prepare your test environment. Ensure you have the latest build of the app installed. If testing on a physical device, check that it has sufficient battery and storage. Set your device to a known state (e.g., airplane mode off, Wi-Fi on).
- Review the requirements. Read the app’s specification or user stories. List the key features and expected behaviors. This becomes your test checklist.
- Test installation and launch. Install the app from the appropriate store or via a direct link. Verify it opens without crashing, shows the correct splash screen, and loads the first screen within a reasonable time (typically under 5 seconds on a modern device).
- Go through each feature screen by screen. For every screen, check:
- All UI elements are visible, aligned, and not overlapping.
- Text is readable, not truncated, and fits within buttons/labels.
- Buttons and links respond to taps and navigate correctly.
- Input fields accept valid data and reject invalid data with clear error messages.
- Scroll works smoothly, including lists and long forms.
- Test user flows end-to-end. Pick a common task (e.g., sign up, login, add item to cart, make a purchase). Perform the entire flow from start to finish, using realistic data. Verify that each step transitions correctly and the final outcome matches expectations.
- Test error and boundary conditions. Try entering extreme values (e.g., very long text, negative numbers, empty fields). Test what happens when the server returns an error (e.g., wrong password). Confirm that error messages are helpful and the app doesn’t crash.
- Test network variations. Switch between Wi-Fi, mobile data, and airplane mode. Verify the app handles loss of connectivity gracefully (e.g., shows a “No internet” message, caches data, or retries). Also test on a slow network (e.g., 3G) to see if timeouts occur.
- Test device-specific features. If the app uses the camera, GPS, push notifications, or sensors, test those on a real device. For example, take a photo, check location accuracy, and receive a push notification.
- Test interruptions. While using the app, trigger interruptions: incoming call, SMS, alarm, or switching to another app and back. The app should resume without losing data or crashing.
- Test orientation and screen sizes. Rotate the device between portrait and landscape. Verify the layout adapts correctly. If testing on multiple devices, check different screen sizes and resolutions.
- Check performance. Monitor app responsiveness: scrolling, screen transitions, and loading times. If the app has animations, ensure they are smooth (no jank). Use the device’s built-in tools (e.g., Android Studio Profiler, Xcode Instruments) if available.
- Test background/foreground behavior. Press the home button, then reopen the app. Verify the app resumes from where you left off. Also test switching between apps and returning.
- Verify data persistence. Close the app completely (swipe away from recent apps) and reopen it. Check that user data (e.g., login state, preferences, in-progress forms) is saved and restored correctly.
- Test accessibility (basic). Increase the device’s font size to the maximum. Check that text is not cut off and that the app remains usable. Also test with a screen reader (VoiceOver on iOS, TalkBack on Android) to ensure key elements are labeled.
- Log defects and retest. For every issue found, record the steps to reproduce, the expected vs. actual result, and a screenshot or screen recording. After fixes are implemented, retest the specific scenario to confirm resolution.
Common Mistakes
- Skipping real-device testing. Emulators cannot replicate hardware-specific behaviors like camera quality, GPS accuracy, or battery drain. Always test on at least one physical device.
- Only testing the happy path. Users will enter wrong data, lose connection, or interrupt the app. Test error cases and edge cases, not just the ideal flow.
- Ignoring network variability. Testing only on fast Wi-Fi misses issues with mobile data, slow connections, and offline scenarios.
- Not documenting steps. If you don’t write down exact reproduction steps, developers can’t fix the bug. Include device model, OS version, and network type.
- Testing on outdated OS versions. Always test on the minimum supported OS version, as well as the latest, to catch compatibility issues.
Tips
- Start with a smoke test. Before deep testing, do a quick pass through the main features to catch obvious crashes or blockers.
- Use a test matrix. Create a table with devices, OS versions, and network conditions to ensure you cover all combinations.
- Take screenshots and screen recordings. Visual evidence is invaluable for developers. Use the device’s built-in capture tools.
- Test on both iOS and Android. Even if the app is cross-platform, behaviors differ. Allocate time for each platform.
- Keep a bug template. Use a consistent format: Title, Steps, Expected, Actual, Device, OS, Severity. This speeds up triage.
- Prioritize bugs by severity. Focus on critical issues (crashes, data loss) first, then major (feature not working), then minor (UI glitches).
Troubleshooting
If something goes wrong during testing, here’s what to do:
- App crashes on launch: Check if the issue is specific to your device or OS version. Restart the device, reinstall the app, and try again. If it persists, report it immediately—this is a blocker.
- Can’t connect to the server: Verify your internet connection. Try switching between Wi-Fi and mobile data. If the app has a server status page, check it. Also ensure the app’s backend is up and you’re using the correct environment (e.g., staging vs. production).
- UI elements are misaligned: This often happens on specific screen sizes. Note the device model and resolution, and test on a device with a similar screen size to confirm.
- Push notifications not received: Check that the app has permission to send notifications in the device settings. Also verify that the app’s push service (e.g., FCM/APNs) is configured correctly—this may require developer assistance.
- Data doesn’t persist after restart: Check if the app is using local storage (e.g., SQLite, SharedPreferences) or server-side storage. If it’s server-side, verify the login session is being maintained. This could be a bug in the app’s lifecycle handling.
- Performance is slow: Close other apps to free memory. If the issue persists, it may be a memory leak or inefficient code. Use profiling tools to identify bottlenecks, or report the steps and device specs.
Frequently Asked Questions
Do I need to test on both iOS and Android?
Yes, if the app supports both platforms. Even with cross-platform frameworks, there are differences in rendering, permissions, and hardware behavior. Allocate time for each platform.
How long should manual testing take?
It depends on the app’s complexity. A simple app might take a few hours; a complex one could take days. A good rule is to spend at least as much time testing as it took to develop the feature.
Can I use an emulator instead of a physical device?
Emulators are useful for early testing, but they cannot replicate hardware features like camera, GPS, or battery usage. Always test on a real device before release.
What is the difference between smoke testing and regression testing?
Smoke testing is a quick check to see if the app’s core features work at all. Regression testing is a full re-test of existing features after changes to ensure nothing broke. Both are important.
How do I report a bug effectively?
Include a clear title, steps to reproduce, expected vs. actual result, screenshots or screen recording, and device/OS information. The more context, the faster the fix.
Should I test on the latest OS version only?
No. You should test on the minimum supported OS version and the latest version, as well as one or two in between. This catches compatibility issues.
Related
General steps for current mainstream versions; menus can differ by device and version. See the disclaimer or report an error.
More in this bed
- How to Play Kodi on Smart TV from PC
- Hogwarts Legacy Microsoft Visual C Runtime Error Fix
- Set Up UPI Payments Through WhatsApp
- Pair Oppo Enco Earbuds with Android, iPhone & Windows
- Fix Administrator Account Disabled Error in Windows 11
- Factory Reset on Samsung Galaxy: What It Erases