Quick answer
Alpha testing is the first round of testing a build gets from people outside the development team, run in the company's own environment before external users see it. It answers whether the product can be used at all, and should end on exit criteria written as numbers, not on a date.
Formula: Core-flow completion = testers who completed the core flow ÷ testers who attempted it; crash-free testers = 1 − testers with a crash ÷ all testers
What is alpha testing?
Alpha testing is the first round of testing a product gets from people who did not build it, run inside the company's own environment before any outside user sees it. The ISTQB glossary defines it as acceptance testing "performed in the developer's test environment by roles outside the development organization": in practice, support staff, sales, designers, other product teams and sometimes a handful of invited customers using a build the engineers hand over.
The question alpha testing answers is narrow: can the product be used at all? Can a person who did not write the code get through the core flow, on the devices the company owns, without crashing, getting stuck or losing data? Whether it is pleasant, fast enough on cheap phones, or stable across thousands of real-world setups is a question for beta testing, which comes next and happens in the users' own environments.
Because the two stages answer different questions, the handover between them should not be a date on a roadmap. It should be a short list of exit criteria written as numbers, decided before the alpha starts.
In software testing the term is used in two slightly different ways. Some teams mean any internal test of an unfinished build, including developers clicking through their own work. The stricter meaning, the one used here, requires testers who are not the developers, because people who wrote the code avoid the paths they know are fragile. Using your own product every day as an employee is close to alpha testing and is often called dogfooding; the difference is that an alpha has a defined build, a defined group, a defined period and an exit decision.
Alpha vs beta vs UAT
The three are often confused because all of them put a build in front of non-developers. They differ in who tests, where, and what has to be true at the end.
| Alpha testing | Beta testing | User acceptance testing | |
|---|---|---|---|
| Who tests | Employees outside the dev team, sometimes a few invited customers | Real external users who opt in | Business owners or the client who will accept the system |
| Where | Developer's environment, company devices and accounts | Users' own devices, data and networks | A staging or UAT environment close to production |
| Product state | Feature-complete or nearly; rough, may crash | Release candidate; stable enough for daily use | Release candidate, often after beta or instead of it |
| Main question | Can it be used at all? | Is it good and stable in real conditions? | Does it meet the agreed business requirements? |
| Typical exit criteria | Core-flow completion rate, crash-free testers, zero open blockers | Crash-free users vs current release, adoption, repeat use | Every acceptance scenario passed and signed off |
User acceptance testing is the odd one out: it is defined by the decision (does the customer or business owner accept it?) rather than by the tester's location. An internal tool can go through alpha and UAT and never have a public beta; a consumer app may run alpha and beta and treat the beta exit as acceptance.
After beta, many teams still release gradually. A canary release sends a small share of normal production traffic to the new build without asking anyone to opt in, which is a different safety net from any of the three tests above.
How alpha testing works, step by step
- Freeze a build and give it a version. Testers must all be on the same build, labelled as such (for example 2.4.0-alpha.3), so every crash and complaint can be tied to it. A clear versioning scheme saves arguments later.
- Write the core flow down. Name the three to six steps a new user must complete to get the product's main value: sign up, create the first project, import data, share a report. This is what "can it be used" means for your product.
- Write the exit criteria before testing starts. For example: core-flow completion of at least 90% of testers who attempt it, no more than one tester with a crash in the final week, zero open P0 bugs. Deciding afterwards invites moving the line to match the result.
- Recruit 20 to 50 internal testers who match the target user. A finance team member is a better test of an invoicing tool than the engineer next door. Exclude people who built the feature.
- Run in rounds of one to two weeks. Each round ends with a fix build. Testers repeat the core flow on the new build so you can compare round to round.
- Collect two kinds of evidence. Measured: who completed which step, crashes per tester and per session, time to complete. Reported: bugs filed with steps to reproduce, confusing screens, missing pieces.
- Decide. Move to beta, run another alpha round, or cut the feature. Record which criterion drove the decision.
Exit criteria: a worked example
Sample data: a project-management app runs a two-round alpha of a new onboarding flow with 40 internal testers. The core flow is four steps: sign up, create a project, import tasks from a CSV, share the project with a teammate. Exit criteria were set before round 1.
| Criterion (set in advance) | Target | Round 1 (build alpha.2) | Round 2 (build alpha.3) |
|---|---|---|---|
| Core-flow completion | ≥ 90% of testers who attempted it | 29 of 36 = 80.6% | 34 of 37 = 91.9% |
| Testers with at least one crash (final week) | ≤ 1 of 40 | 3 of 40 (crash-free testers 1 − 3 ÷ 40 = 92.5%) | 1 of 40 (crash-free testers 1 − 1 ÷ 40 = 97.5%) |
| Sessions ending in a crash | ≤ 0.5% | 3 of 412 = 0.73% | 1 of 455 = 0.22% |
| Open P0 bugs | 0 | 1 (CSV import loses rows over 500 lines) | 0 |
| Decision | Another round | Move to beta |
Two details in this table matter more than the numbers themselves.
First, the crash criterion is written as a count of testers, not as a percentage like "99.5% crash-free". With 40 testers, each person is worth 2.5 percentage points (100 ÷ 40 = 2.5), so crash-free testers can only be 100%, 97.5%, 95% and so on. A 99.5% target would really mean "zero crashes", which is stricter than intended and says nothing useful about how the build will behave for thousands of users. Adding the per-session rate gives a second view that moves in smaller steps.
Second, round 1 failed on two criteria even though most testers got through. Seven of 36 people could not finish the flow, and the reason was a single P0 bug in CSV import. The rule made the decision for the team: fix, ship alpha.3, repeat the flow. Only when completion and stability both cleared their bars did the build move to a beta where the questions become "is it good and stable for strangers", measured against much larger numbers. For reference, Google Play treats a user-perceived crash rate above 1.09% across devices, averaged over 28 days, as bad behavior for a public app; that is the kind of yardstick that belongs in beta and release criteria, not in a 40-person alpha.
What alpha testing usually finds
- Blocking defects on the core flow. Crashes, data loss, a step that cannot be completed. These are the reason the stage exists.
- Assumptions only developers share. Labels that use internal jargon, a step that relies on a setting engineers always have turned on, a test account with admin rights that hides permission bugs.
- Missing pieces. No way to undo, no empty state, no error message when an import fails.
- Instrumentation gaps. Events that never fire or fire without the properties the release dashboard needs. Catching these in alpha means beta data is usable from day one.
What alpha rarely finds: problems that depend on real data volume, slow networks, old devices and unusual configurations. Company devices and office Wi-Fi are too uniform, which is why a passed alpha is a ticket to beta, not to release. Performance on low-end hardware, for instance, needs the device spread of a beta; see how to improve app performance for what to measure there.
Common mistakes
- Letting the developers be the testers. They avoid the fragile paths without noticing. Use people from other teams.
- No written exit criteria. The alpha ends when the beta date arrives, whatever the results. Write three to five numbers first.
- Percentages that a small group cannot hit. With 40 testers, use counts ("no more than one tester with a crash") or per-session rates.
- Mixing builds. Testers on alpha.2 and alpha.3 at the same time make every number ambiguous. Force the update or report by build.
- Treating feedback volume as quality. Ten reports about button colour and one about lost data are not equal. Triage blockers first.
- Skipping the data check. If the release dashboard depends on events that were never verified in alpha, the beta will produce numbers nobody trusts.
Measuring an alpha in TapCub
Take the worked example above: 40 testers, two builds, a four-step core flow. In TapCub the measured half of the decision comes from the same SDK that will later measure the beta and the release.
- Separate the alpha build. App analytics › Users › Versions lists each app version with its share of active users, crash count and first-seen date, so alpha.2 and alpha.3 appear as separate rows and round 1 is not blended with round 2. See track app versions.
- Check stability per build. App analytics › Quality & attribution › Stability shows the crash-free share (1 − crash users ÷ active users), crash count, ANRs and UI freezes, plus error groups you can mark active, resolved or ignored. With 40 testers, read the crash user count next to the share, as in the example. See crash-free rate.
- Measure core-flow completion. Build the four steps as a funnel in All-platform analytics › Behavior › Behavior analysis and filter it to the alpha version: the funnel gives the share of people who reached each step and where the seven who did not finish dropped out.
- Verify the events before beta. In All-platform analytics › Data › Tracking plan, keep the new onboarding events at the Accepting status during the alpha and turn on Live verification (24 h), which adds hits in the last 24 hours and the completeness of required properties for each event. Move them to Live once they arrive complete.
- Mark the rounds on the charts. Add each alpha build as an annotation in Configuration › Annotations, so a later jump in a trend can be traced back to the build that caused it.
TapCub does not manage test cases, bug reports or tester recruitment; those stay in your issue tracker. It supplies the numbers the exit criteria are written in.
See also: What is smoke testing? Definition, 8-item checklist and a release-day example.
Sources
- ISTQB Glossary, alpha testing.
- ISTQB Glossary, beta testing.
- Android Developers, Android vitals: core vitals and bad behavior thresholds.
Was this explanation clear?
We use your answers to fix and expand this page.
Couldn’t send. Please try again in a minute.
Thanks for the feedback. We’ll use it to improve this page.You’ve already sent feedback on this page. Thanks.

Technical Engineer
Focuses on tracking code, SDKs, and API integrations, with practical guidance on implementation checks and troubleshooting.