One of Your 12 Google Play Testers Dropped Out — Do the 14 Days Start Over?

For a while I had a morning habit: open the tester list, count who was still opted in. One morning the 12 I expected had become 11, and my stomach dropped.

Had all those days just been wiped out? Or did I only need to wait for the one person who left? Searching turned up "everyone restarts" and "only that person" with equal confidence, and I couldn't tell which to trust.

What I'd like to say first: what you count is not the overall number of days, but each tester's unbroken streak. If you're preparing to ship a Rork-built app to Google Play, here is what the official help text says, and how I count it by hand.

What the official help page says

This applies to personal developer accounts created after November 13, 2023. The Play Console help page on app testing requirements for new personal accounts lays out the following.

Once the testing requirement is met, you open the Dashboard in Play Console and choose "Apply for production." The form has three sections: your closed test, your app, and your production readiness. Review usually finishes within seven days, though it can take longer.

Not "everyone restarts" — only that person's clock goes back

Reading the table plainly: the 14 days belong to each tester. If one person leaves on day 9, the other 11 keep their progress. What stalls is the slot that person was holding.

You need both of these to be true on the same day:

• At least 12 testers have completed an unbroken 14 days
• Those 12 are still opted in when you apply

If the person who left comes back, they start counting again from the day they rejoined; the earlier 8 or 9 days don't carry over. So the date your 12th tester reaches 14 days moves to 14 days after whoever fills the gap joined.

That is my reading of the official wording. The console doesn't show a "day N" counter, so whether the Apply button is available is the final answer.

A small script to count it yourself

The number of people currently opted in doesn't tell you how many have reached 14 days. I keep a table of join and leave dates and count per person. The goal is a single date: when the 12th tester reaches 14.

from datetime import date, timedelta
 
REQUIRED_TESTERS = 12
REQUIRED_DAYS = 14
 
# opt-in / opt-out records. None as the end date means still opted in.
log = {
    "tester01": [(date(2026, 10, 1), None)],
    "tester02": [(date(2026, 10, 1), date(2026, 10, 9)), (date(2026, 10, 12), None)],
    "tester03": [(date(2026, 10, 2), None)],
}
 
def longest_streak(spans, today):
    """Longest unbroken run of days for one tester."""
    best = 0
    for start, end in spans:
        best = max(best, ((end or today) - start).days)
    return best
 
def completed_date(spans):
    """First date an unbroken 14 days is reached (None if never)."""
    for start, end in sorted(spans):
        done = start + timedelta(days=REQUIRED_DAYS)
        if end is None or end >= done:
            return done
    return None
 
def report(log, today):
    ok = []
    for name, spans in sorted(log.items()):
        s = longest_streak(spans, today)
        d = completed_date(spans)
        mark = "OK " if d and d <= today else "WAIT"
        print(f"{mark} {name}: longest streak {s:>2} days / reaches 14 on {d or '-'}")
        if d:
            ok.append(d)
    ok.sort()
    if len(ok) >= REQUIRED_TESTERS:
        print(f"12th tester reaches 14 days on: {ok[REQUIRED_TESTERS - 1]}")
    else:
        print(f"{len(ok)} testers on track for 14 days; {REQUIRED_TESTERS - len(ok)} short")
 
report(log, date(2026, 10, 19))

Running it on three sample testers prints:

OK  tester01: longest streak 18 days / reaches 14 on 2026-10-15
WAIT tester02: longest streak  8 days / reaches 14 on 2026-10-26
OK  tester03: longest streak 17 days / reaches 14 on 2026-10-16
3 testers on track for 14 days; 9 short

tester02 left on day 9, so the count restarts from the October 12 rejoin and reaches 14 on the 26th. completed_date accepts a span only if the tester stayed until at least 14 days after joining; a span that ends earlier is thrown away entirely.

I copy the join and leave dates by hand from the Play Console tester screen. I haven't confirmed whether there's an automatic way to export them.

Where I got the line wrong

At first I only looked at headcount. "Eleven now, so I'll add one and get back to twelve" — and I tried to apply the same day. It didn't go well: the newcomer had only a few days behind them and didn't meet the requirement.

My rule now: look at how many testers have reached 14 days, not how many are in the list. I run the script once before every application.

Making dropouts less likely

Giving yourself slack at the start was far easier than recovering later.

• Don't start with exactly 12; invite a few extra
• Say "please stay opted in for 14 days" in your invitation
• Some people leave right after joining, so check the count each morning for the first few days
• Testers don't need to start on the same day, but you need the 12th one to reach 14

That last point means a late joiner pushes the overall finish date back. If you're in a hurry, filling the slots early pays off.

If another deadline is in play

Play also has target API level deadlines separate from the testing period. If they might overlap, work backwards from them first.

• The August 31 target API 36 date means different things depending on whether you ship an update
• What surprised me first when I took a Rork app to Android — App Store vs. Google Play

The next step for today: put your testers' join and leave dates in a table and run the script once. As an indie developer I intend to keep counting this way the next time I ship an app, too.