Skip to content
99tests Blog
Free tools

Build a release test plan in two minutes with the free test plan builder

Pick the flows your release touches, choose P1 or full depth, and download one test plan as CSV or Markdown, with real-phone cases marked and the run priced. Worked example.

Hand-drawn sketch of a stopwatch beside a laptop with a ticked checklist and a download arrow, titled Build a Release Test Plan in Two Minutes
In this article
  1. How it works
  2. A worked example: a release that touches login and payments
  3. Tips for a better plan
  4. Release lead checklist
  5. Release-blocking criteria
  6. Go/no-go decision template
  7. Example: completed no-go decision
  8. Example: completed go decision
  9. Release owner sign-off checklist
  10. From plan to report
  11. Try it

Most release test plans start as a blank spreadsheet the night before the release. The 99tests test plan builder gives you a faster starting point: 950 written test cases organized by flow. Tick the flows your release touches, choose how deep to go, and download one plan as CSV or Markdown. The export marks cases that need a real phone, so you can separate device work from checks that do not need one. The builder also shows which fixed-price test run the selected plan fits. It's free, with no sign-up.

The useful part is not just getting a list of cases. It's being able to answer practical release questions before testing starts: Which flows are in scope? What must pass before shipping? How many cases need physical devices? And does the selected run have room for them? You can make those choices in the builder, then review the resulting rows with your team.

How it works

  1. Pick the flows. The 25 flows from the free test case library are grouped into login and identity, payments, KYC and lending, shopping and travel, and mobile platform. Each flow shows its case count and how many cases need a real phone. Start with the screens and journeys changed in this release, then check adjacent flows that rely on the same code. For example, if you changed login validation shared by OTP login and forgot password, include both rather than testing only the screen named in the ticket.
  2. Choose the depth. Select all cases, P1 + P2, P1 only, or only cases that need a real phone. P1 is a workable first pass when you need a release-blocking checklist. P1 + P2 gives you a broader run before a larger launch, while all cases is useful when you want to examine the full set. The real-phone filter answers a different question: which selected checks should be assigned to physical devices?
  3. Choose platforms and devices. Select Android, iOS or web, and enter how many phones or browsers you want per platform. Match this to the release you are actually shipping. If only the Android app changed, you can build an Android plan; if the same checkout change also affects web, include the browser coverage you intend to run. Device count helps you plan execution, but it does not replace choosing the flows and cases.
  4. Download or share. Export CSV if you want to sort rows, assign owners or add app-specific cases in a spreadsheet. Choose Markdown if you want to paste a readable checklist into a release note or team document. You can also copy either format. The whole plan lives in the page address, so a teammate who opens your link sees the same selections and can review the scope before anyone starts testing.

A worked example: a release that touches login and payments

Say your next Android release changes the OTP login screen and the UPI checkout. An OTP change could affect entering a code, handling wrong attempts or returning to the app after reading an SMS. A checkout change raises a different set of questions, including what happens if a person taps Pay twice or loses connectivity after submitting a PIN. We built a plan for these two flows on 10 November 2026, with two phones.

DepthCasesNeed a real phoneFitsPrice per release
All cases7829Deep: 20 × 90-minute sessions on up to 6 devices, ~120 cases₹34,999 + GST ($449)
P1 only219Starter: 5 × 45-minute sessions on 2 devices, ~25 cases₹9,999 + GST ($129)

The full plan has 38 OTP cases and 40 UPI cases. Filtering to P1 brings the combined list down to 21 release-blocking checks. That is a reduction in scope, not a claim that the other 57 cases no longer matter. You can use the smaller plan for a routine change, then return to the broader set when the risk or size of the release warrants it.

Here are some of the P1 cases, and why they belong in the conversation:

  • OTP-01: log in by typing the OTP from the SMS. This checks the basic path a user needs to finish signing in.
  • OTP-09: the code is blocked after the set number of wrong attempts. This checks that a failed-login limit still works after the screen changes.
  • OTP-22: the app is killed while the user reads the code in the messages app (real phone). This covers an interruption that a simple, uninterrupted login test misses.
  • OTP-28: the OTP reaches a number with carrier do-not-disturb turned on (real phone). This puts the delivery scenario on the physical-device list.
  • UPI-21: a double tap on Pay causes only one debit. This tests the outcome of an easy-to-make user action, not just whether the button responds.
  • UPI-23: the network drops right after the UPI PIN is submitted (real phone). This checks a failure point where the payment result may need careful review.

The table makes the scope trade-off visible. In this worked example, the 21-case P1 plan fits the ₹9,999 Starter run, while the 78-case full plan fits the ₹34,999 Deep run. If your release is small, you can start with P1 and record why you deferred the rest. If it is the first release after a rewrite, reviewing all 78 cases gives you a fuller checklist. The figures above describe this example from 10 November 2026; check the current package details before booking.

Tips for a better plan

Plan by what changed. Tick the flows the release touches, plus flows that share code or hand-offs with them. A login change might call for OTP and forgot-password coverage even if the ticket mentions only one screen. A payment change may deserve a look at the return path from a UPI app as well as the Pay button itself. Write down the reason for adding each adjacent flow so the scope stays deliberate.

Keep P1 for every release, P1 + P2 for big ones. Treat P1 as the smallest set you expect to pass before shipping, not as a substitute for every other test. Add P2 before a launch, a sale or a major version when you want broader checks around the main path. If you choose P1 only for a smaller release, note what you left out so those cases can be picked up in a later cycle.

Send real-phone cases to real phones. Filtering to "only cases that need a real phone" gives you a device-work list for situations such as OTP auto-read, switching to a UPI app, battery-saver behavior and network drops. For example, an OTP case that requires leaving the app to read a message should be planned differently from a straightforward code-entry check. Use the marker to allocate the right equipment and time, rather than assuming every row can be settled in the same environment.

Add your own cases. Every exported row carries the case ID, flow, priority and whether it needs a real phone. Use those fields to keep the standard cases easy to trace, then add app-specific rows at the bottom of the CSV. If your checkout has a custom promo step, for instance, add a case for applying a code before paying and another for returning to the checkout after a failed payment. Give new rows clear IDs and expected outcomes so someone else can run them without interpreting a vague reminder.

Review the plan with the people who will run it. Before sending the link or CSV, ask whether the selected platforms, device count and priority filter match this release. A short review can catch a missing flow or a phone-only case that has no device assigned. It also gives the team a shared answer when someone asks why a case was in or out of scope.

Release lead checklist

Before you hand off the plan, confirm:

  • Scope: List the changed flows and any adjacent flows that share code or hand-offs. Note why each one is included.
  • Depth: Choose P1, P1 + P2 or all cases based on the release risk. Record any checks you defer and when you expect to run them.
  • Platforms: Select only the Android, iOS and web versions this release affects, and check the planned phone or browser count for each.
  • Real-phone work: Review the marked cases. Make sure someone has the devices and time needed for SMS, app switching and network-interruption checks.
  • App-specific cases: Add checks for changed features the standard flows do not cover, with a clear action and expected outcome for each.
  • Capacity: Compare the case count with the package the builder suggests. If a booked run will not cover every case, identify what will remain not run rather than treating it as passed.
  • Handoff: Share the plan link for scope review, then keep the exported CSV with the build used for the run. Confirm the team can access the build and has the information needed to execute each case.
  • Release decision: Review failed and not-run cases separately in the report. Assign follow-up owners and decide which outstanding checks block shipping.

Release-blocking criteria

Agree on blockers before testing. A P1 label alone does not decide whether a failure blocks this build; record the impact, evidence and decision owner.

Keep the release at no-go until fixed and retested if:

  • Users cannot complete a core journey, such as OTP login or UPI payment, on a platform being released.
  • A payment or account action has an unsafe outcome, such as a double debit, or bypasses a security control.
  • A critical hand-off fails or remains untested, and no other evidence establishes the result.
  • A required real-phone check is not run on a physical device, and the decision depends on that behavior.

Use conditional go only when the decision owner accepts a bounded risk with an identified impact, verified workaround if applicable, owner and follow-up date. Unknown impact stays no-go. Record non-blocking failures and deferred checks even for a go decision.

Go/no-go decision template

Copy this into your release note or ticket after reviewing the report. Do not count not-run cases as passed.

Build: ___
Release date: ___
Decision: go / conditional go / no-go
Decision owner: ___
Plan link or CSV: ___
Flows, platforms and depth: ___
Results: ___ passed; ___ failed; ___ not run
Real-phone cases completed: ___ of ___
Blockers and deferred checks (impact and owners): ___
Fixes or retests: ___
Next decision date: ___
Decision reason: ___
Remaining work owner and due date: ___

Keep the completed decision with the plan and report.

Example: completed no-go decision

Fictional example, not an actual test result. For Android build 4.8.0-rc2, the release lead records no-go against the 21-case P1 OTP and UPI plan on two phones. 19 passed, 1 failed, 1 was not run; 8 of 9 real-phone cases were completed.

UPI-21 caused two debits after a double tap in this example. The payments engineer must fix and retest it. UPI-23, the network-drop check, remains not run; the QA lead must run it on a physical phone. The release lead will decide again after both results are recorded.

Example: completed go decision

Fictional example, not an actual test result. For Android build 4.8.0-rc3, the release lead records go against the same 21-case P1 plan on two phones. All 21 passed; none failed or were not run; 9 of 9 real-phone cases were completed. UPI-21 passed after the fix, and UPI-23 was run on a physical phone. No blocker remains open.

The other 57 cases were outside this P1 run, not passed. Archive the report with the plan and build, and decide separately when to cover them.

Release owner sign-off checklist

Before approving the build, confirm:

  • Build and scope: The report matches the release build and exported plan; fixes were retested on the new build.
  • Coverage: Planned flows, platforms and case IDs match the report; required phone checks ran on physical devices.
  • Exceptions: Review evidence for every failed, blocked or not-run case. None counts as passed.
  • Decision: Apply the blocking criteria. For a conditional go, record the impact, verified workaround if applicable, owner and follow-up date; unknown impact stays no-go.
  • Record: Save the signed go, conditional go or no-go decision with the plan, report, build and review date.

From plan to report

The plan's last step is a button to run it on real phones. When you book, upload the CSV with your build and choose the package the builder suggested. 99tests parses uploaded test cases into a plan and shows the coverage before testers start. Testers then run cases on their own phones and networks.

Keep the export you booked against so you can compare the report with the intended scope. For example, if the release plan includes OTP-22 and UPI-23, you can check their reported outcomes alongside the rest of the phone-specific cases. Cases that do not fit the run are listed as not run in the report, never quietly passed. That distinction matters: a passing result tells you a case was exercised successfully, while a not-run result tells you coverage is still outstanding.

Try it

Open the test plan builder, or start with this example plan for OTP login and UPI payment. Change the flows, depth and platforms to match your own release, then export the plan for review. If you are deciding between a short run and fuller coverage, compare both selections before downloading: the case count and real-phone count make the difference easier to discuss with your team.

Share

Get new articles by email

No spam. Unsubscribe anytime.