950 free test cases for UPI, OTP, Aadhaar eKYC and 22 more Indian app flows
A free library of 950 ready-to-run test cases for 25 Indian app flows, from UPI and OTP login to Aadhaar eKYC and train booking. Download CSV or Excel. Example: UPI payment.
In this article
Generic test case templates are often written for a simple login page. They rarely cover a UPI payment stuck in Pending, an OTP that lands on the wrong SIM of a dual-SIM phone, or a merchant app killed by a battery saver while the user is in a UPI app. Those are the cases that break Indian apps in the field. A form can pass every validation check in a simulator and still fail when a customer switches apps, loses signal in a lift, or receives an SMS on a different SIM.
The 99tests test case library has 950 test cases across 25 flows that Indian apps run every day. It's free, with no sign-up. Every case includes steps, an expected result and a priority. Another 307 are marked as needing a real phone, with a reason for that requirement. You can use the cases as a starting point for a new test plan, a release smoke test, or a gap check against cases your team has already written.
The 25 flows
| Group | Flows |
|---|---|
| Login and identity | Login page, OTP login, mobile number sign-up, forgot password, biometric login |
| Payments | UPI payment, UPI AutoPay, QR code scan and pay, payment gateway checkout, bank fund transfer, recharge and bill payment |
| KYC, lending and investing | Aadhaar eKYC, digital loan application, stock trading order |
| Shopping, delivery and travel | Shopping cart, checkout, in-app search, food delivery tracking, cab and auto booking, train ticket booking |
| Mobile platform | Push notifications, offline and poor network, app update, Hindi and regional languages, runtime permissions |
Start with the flows a user must complete to get value from your app, then add the platform conditions that can interrupt them. A payments app might combine OTP login, UPI payment, QR scan and pay, push notifications, and poor-network cases. A lending app might prioritize mobile number sign-up, Aadhaar eKYC and the digital loan application, then check how those flows behave when permissions are denied or the app is interrupted.
Each flow has 34 to 40 cases in up to seven sections: happy path, validation, edge cases, interruptions and network, device and OS, security and privacy, and accessibility and language. A happy-path case establishes that the ordinary journey works. The other sections ask what happens when, for example, a user enters an expired OTP, switches away during checkout, loses connectivity after submitting a request, or uses a larger text size. Across the library, 269 cases are marked P1. Treat those as release-blocking checks, not as a replacement for the remaining cases when you have time for a fuller run.
A worked example: UPI payment
The UPI payment flow has 40 cases. Thirteen are P1, and thirteen need a real phone. The four below show how a single flow can span bank-response delays, network loss, app switching and SIM selection. For each one, record not just what the UI says, but also what happened to the payment or order so that a reassuring screen does not hide an incorrect outcome.
UPI-17: Pending payment resolves to success without a second debit (P1). With a delayed bank response, pay and stay on the result screen. Expected: the screen shows Pending with advice not to pay again, then changes to Success with only one debit. This checks whether the app handles an uncertain response without nudging the user into paying twice. When adapting it to your app, verify the payment record and the related order state as well as the message on screen.
UPI-23: Network drops right after the UPI PIN is submitted (P1, real phone). Submit the PIN, turn on airplane mode within a second, then repeat while walking into a lift or basement. Expected: the app shows Pending or Checking while offline, never Failed, and doesn't ask the user to pay again. Why a real phone: real dead zones lose packets slowly, while an emulator's network cut is instant and clean. Repeating the case with different timings helps reveal whether the app treats a missing response as a confirmed failure.
UPI-26: Merchant app killed while the user is in the UPI app (P1, real phone). On a 3-4 GB RAM phone, start a payment from the merchant app, open a few heavy apps, then finish the PIN. Expected: the merchant app checks the status on reopening and shows the order as paid. Why a real phone: low-RAM phones and their makers' memory managers kill background apps during app switching. The important check is what the merchant app does after it restarts, not just whether the UPI app reports success.
UPI-29: Bind the device with the right SIM on a dual-SIM phone (P1, real phone). Choose the SIM registered with the bank during onboarding. Expected: the app names the slot it will use and sends the verification SMS from it. Why a real phone: the binding SMS goes out from a physical SIM slot over the carrier network. Run this with both SIM slots populated so a default-SIM setting does not mask a selection error.
Every flow page also lists where that flow breaks in the field. For UPI, one example is a merchant app being killed on a Xiaomi, Vivo, Oppo or Realme phone with 3-4 GB of RAM while the user is in the UPI app. The account is debited, but the order still appears unpaid. That is a useful reminder to test the handoff and recovery path, not only the payment screen itself.
A worked example: OTP login
The OTP login flow has 38 cases. To turn them into a useful release check, test more than whether a correct code opens the app. First note the build's configured OTP validity period, resend wait time and attempt limit. Then run the same journey with a valid code, a stale code and an interrupted session. Use test numbers and approved SMS access rather than a customer's account.
Start with a valid code. Enter a registered mobile number, request an OTP and complete login before the code expires. On Android, check SMS auto-read where your app supports it; on iPhone, check the platform's code suggestion. Expected: the code is applied to the number that requested it, the user signs in once, and the app lands on the right screen. If autofill does not appear, confirm that manual entry still works instead of treating autofill as the only route to login.
Let the code expire, then request another. Request an OTP, wait beyond the configured validity period and try the old code. Expected: verification fails, the app explains that the code expired and Resend is available when the wait period allows it. Request a new code, then try the old code again before entering the new one. This separates an expired-code check from a resend check and helps catch a login that accepts a code it should no longer trust.
Leave the app during the resend countdown. Request an OTP, switch to another app and return after the countdown should have finished. Expected: Resend is available on return, not stuck at the time remaining when the app went into the background. Repeat with an SMS arriving while the app is away. Check that the code is still associated with the original phone number and that returning to the app does not trigger an extra OTP request.
Check delivery on a dual-SIM phone. Put active SIMs from different carriers in a physical phone and send the OTP to the number on the SIM that is not carrying mobile data. Enter the code manually if needed, then switch the data SIM and repeat. Expected: the SMS reaches the requested number, login does not silently switch numbers, and any phone-number suggestion identifies the right SIM or shows no number when one is unavailable. This is a real-phone check: a simulator cannot stand in for two physical SIMs and their carrier SMS behavior.
For each run, record the phone number used in a safe, masked form, the device and carrier, the build, and whether the code arrived, autofilled and verified. If login fails, those details help distinguish an SMS delivery problem from an app state or verification problem. The OTP login cases also cover incorrect attempts, late or repeated messages, and changing the phone number mid-flow; add those when the release touches OTP handling.
A worked example: Aadhaar eKYC
The Aadhaar eKYC flow is useful for testing more than whether a user reaches a verification-success screen. The journey depends on informed consent, the authentication method your integration supports, and how the app handles a response that is delayed or unsuccessful. Before running it, confirm your provider's test environment, approved test identities and expected error mapping. Do not use a customer's Aadhaar details or record an unmasked number, OTP or eKYC response in a defect report.
Check consent before requesting verification. Start eKYC and review what the app tells the user about the data requested and its purpose. Continue once with consent, then repeat without giving it. Expected: the app does not start authentication or retrieve eKYC data before consent, and declining consent does not look like a completed verification. Check that the consent recorded by your system matches the action the user took. UIDAI's notice and consent guidance calls for informing the resident and obtaining consent before authentication or verification.
Complete the supported OTP route, then try a wrong code. Using approved test data, request an OTP for the registered mobile number and complete verification with a valid code. Repeat with an incorrect code, then request a new one if your integration allows it. Expected: the valid request advances only the right applicant's session; an invalid OTP does not mark the applicant as verified, and the user gets a clear way to retry. UIDAI documents an invalid-OTP response, but the message your app shows should be understandable without exposing a raw service error. If your app supports biometric authentication instead, adapt this check to a successful scan and a mismatch on the supported device rather than assuming every integration uses OTP.
Interrupt the flow while verification is pending. Submit an authentication request in the test environment, then background the app or interrupt its connection before the result appears. Reopen it and inspect both the screen and the applicant record. Expected: the app checks the outcome or presents a safe retry path; it does not claim success solely because a request was sent, and it does not create two completed KYC records after a retry. Run the device-interruption version on a physical phone if that is a risk for your users. A clean network toggle in a simulator will not reproduce every background-app or mobile-signal transition.
Separate a service problem from an applicant failure. Ask your provider how to simulate a temporary eKYC-service error or unavailable resident data. Expected: the app explains that verification could not be completed now, keeps the application in an accurate state, and allows only the retry your integration supports. It should not tell the applicant their identity failed when the service could not return a result. The UIDAI eKYC API specification distinguishes authentication failures from conditions such as temporarily unavailable data, so check the error mapping as well as the on-screen message.
For each run, record the build, device, authentication route, consent choice, test-environment response and final application state. Keep sensitive values masked. If the UI and the backend disagree, the case is not complete just because the screen looks reassuring. Add your integration's document, permission or biometric-device conditions where applicable, but do not assume every Aadhaar eKYC implementation offers the same route.
Test plan for the three worked examples
Use this table to assign the UPI, OTP and Aadhaar eKYC checks for a release run. The owners are suggested roles, not named people. Replace them with your team's assignees, then add your app's screen names, approved test data and run date.
| Flow | Suggested owner | Set up and run | Confirm before marking pass |
|---|---|---|---|
| UPI payment | Payments QA lead, with a backend or payments engineer to verify records | Run a delayed bank response, a network drop after PIN submission, a merchant-app restart during the UPI handoff, and device binding with both SIM slots populated. Use a physical phone for the cases marked real phone. | Pending does not prompt a second payment; a resolved success has one debit; the merchant order agrees with the payment record; the binding SMS uses the selected bank-registered SIM. |
| OTP login | Mobile QA owner, with an authentication engineer for verification failures | Note the configured validity period, resend wait and attempt limit. Run a valid code, an expired code followed by resend, a backgrounded countdown, and delivery to the non-data SIM on a dual-SIM phone. | Only the requested number's current valid code signs in; old codes stay invalid after resend; the countdown resumes correctly; manual entry works if autofill does not; returning to the app does not request another OTP unexpectedly. |
| Aadhaar eKYC | KYC QA owner, with an integration or compliance reviewer for consent and response mapping | Use approved test identities and your provider's test environment. Run consent granted and declined, valid and invalid authentication, an interrupted request, and a simulated service problem where supported. | No authentication starts before consent; only the right applicant session advances; an interrupted or retried request does not create duplicate completed records; service errors are not shown as identity failures. |
For every case, the assigned owner should record the build, device and OS, network or carrier where relevant, test-environment setup, actual result and final backend state. Attach safe, masked evidence and a defect reference if the case fails. Mark a case blocked rather than passed when a bank response, carrier SMS or provider error cannot be simulated. Have the supporting reviewer check the system record alongside the UI before signing off on a payment, login or verification result.
How to use the library
Filter to what you need. Each flow page filters to all cases, P1 only, or real-phone cases only. For a quick check before release, select P1 for the flows your update touches. If the release changes app switching, SMS handling or permissions, also review the real-phone filter. For a broader regression run, include the lower-priority cases that explore validation, language and accessibility behavior.
Download or copy. Take any flow as CSV or Excel, or copy it as CSV or Markdown into Jira, TestRail, a Google Sheet or a pull request description. Add fields for your app's screen names, the test device, actual result and defect reference. For example, replace a generic instruction to open the payment screen with the navigation steps in your own checkout, while keeping the failure condition and expected outcome intact.
Check your AI-generated cases against it. If a coding assistant wrote your test cases, compare them with the matching flow section by section. A generated UPI suite might cover valid and invalid PIN entry but omit a lost response after PIN submission. An OTP suite might check expiry and resend but overlook dual-SIM delivery or what happens when the app is backgrounded. Use those gaps to add targeted cases rather than duplicating every row.
Combine flows into one plan. "Add to a test plan" sends the flow to the free test plan builder, which merges flows and tells you what the run would cost. A shopping app with UPI checkout, for instance, can bring together checkout, payment gateway, UPI payment and poor-network cases so the team sees the journey across screens. You can then prioritize the cases most relevant to the release instead of running each flow in isolation.
The cases use no app or bank brand names and only fake sample values, so you can adapt them to your own app. Replace those values with approved test data and map each expected result to what your system can actually verify. Keep the original interruption or device condition when you adapt a case: that condition is often the reason the case exists.
Run them on real phones
The library tells you what to test. The 307 real-phone cases only mean something when run on real phones, real SIMs and real networks. An emulator can help you check that a screen renders and a validation message appears. It cannot reproduce every carrier-SMS behavior, device-specific background kill, or gradual loss of mobile signal. Keep an emulator in the workflow for fast feedback, then reserve physical devices for the cases marked as needing them.
Build a small device matrix around the risks in your app. For OTP and UPI onboarding, include a dual-SIM configuration if your users have one. For app-switching and recovery, include a lower-memory phone. For offline behavior, check both an immediate disconnect and a less predictable transition between coverage areas. Record the model, OS and network alongside the result so the team can reproduce a failure instead of treating it as a one-off.
99tests testers across India run your cases on their own phones, including Android phones and iPhones on Jio, Airtel and Vi. They verify findings, and reports include screenshots, reproduction steps and device details. The stated starting price is ₹9,999 + GST for up to ~25 cases on 2 phones. If you are deciding what to send to real devices first, start with P1 cases that involve SIMs, network transitions, payment handoffs or background-app recovery.
Try it
Browse the test case library if you want to compare all 25 flows, or start with the one closest to your next release: UPI payment, OTP login or Aadhaar eKYC. Pick the P1 cases first, then note which ones require a real phone and why. That gives you a focused first run before you expand to the full flow.
If you are unsure which flows are causing trouble for users, run your app through the Play Store bug scanner. Use what you learn from user complaints to choose the flows to inspect, then check whether your current test plan covers their interruption, network and device cases.