Multi-tab testing should check what happens when one person opens the same SaaS record twice, saves a change in one tab and then saves an older view in the other. Define which edits should survive, how a conflict is explained and whether unsaved text remains recoverable. A successful save message alone does not establish that the resulting record is correct.
This is a useful public-demo request because a peer can reproduce it with safe sample data. They do not need your source code to notice that an earlier edit disappeared. They do need a clear starting record, save order and expected outcome.
The task-review app below is fictional. The walkthrough is an original manual test plan, not a claim that I tested Buildside or any other product. It focuses on one account in two tabs; that differs from two people with different permissions editing together.
Choose a record and define the competing changes
Create a disposable sample task with a title and description that are easy to recognize. Open the task in tab A and tab B before changing either one. Both views should begin from the same saved version for this first test.
In tab A, change the description from a short sample sentence to a longer explanation. Save it and confirm the ordinary success state. In tab B, change only the title while leaving its old description untouched, then save.
Now inspect the authoritative current record by reopening it through the product's normal navigation. Did the new title and new description both survive? Did tab B overwrite tab A's description? Did the app reject the stale save and explain why?
There is no universal requirement that every product merge every change automatically. The requirement is to choose and communicate behavior appropriate to the task. A deliberate conflict warning can be better than an apparently successful save that silently discards another edit.
Distinguish the current view from unsaved work
A tab can contain both an old saved version and new text the person has typed. Refreshing everything may update the former while losing the latter. Those are different pieces of information and deserve different expectations.
For the fictional task app, propose a clear rule: when a conflicting saved version is detected, keep the person's unsaved title available while showing that the description changed elsewhere. The person can then review the current record and decide how to continue.
This is a design choice for the example, not a claim about a particular library. Your product may offer a comparison, a recoverable draft or another route. Explain what the user can do next without requiring them to understand storage versions or request headers.
Test the words as well as the outcome. “Conflict” with no context may be accurate internally but unhelpful. The person needs to know that another saved version exists, whether their own typing is safe and which action could replace or discard it.
Run the save order in both directions
After the first attempt, reset the safe fixture and reverse the order. Save the title in tab B first, then the description in tab A. Record each outcome rather than assuming the same policy will apply in both directions.
Next, make both tabs edit the same field with visibly different sample text. This creates a different decision from changing separate fields. An automatic merge of independent edits does not tell you how the app handles competing descriptions.
Keep the sequence deliberate. The first manual review does not need two people trying to click at the exact same millisecond. An older tab saving after a newer version already exists is enough to inspect an important stale-edit path.
A rapid simultaneous attempt can be a later check with suitable technical support. Do not describe a handful of manual saves as proof that all concurrency conditions are safe. The evidence is about the exact starting states and orders attempted.
Check what another tab is told
A product may update tab B as soon as tab A saves, show a notice when B regains focus or discover the mismatch only when B tries to save. Inspect the behavior that actually occurs. Do not infer it from how quickly a badge changes.
MDN's Broadcast Channel API documentation describes communication between browsing contexts within the same origin and storage partition. It also makes clear that the application defines what the messages mean. A browser message is a possible coordination mechanism, not a server-side guarantee that conflicting writes cannot overwrite each other.
That distinction matters for the test. Seeing an “updated elsewhere” notice is useful, but you still need to inspect the saved record after the attempted action. Conversely, an app can protect a stale save even if it does not update the other tab immediately.
Keep browser coordination and durable data protection separate in the review notes. A peer can report the visible behavior. The developer can then investigate which part of the implementation produced it without treating a particular browser API as the entire solution.
Include an ordinary interruption
Once the clean sequence is understood, let tab B sit while doing a short unrelated task. Return to it and attempt the same title edit after tab A has saved. This checks the familiar situation in which the person forgot an older tab was open.
Record the elapsed period when it matters, but do not invent a timeout boundary from one attempt. The question is whether the product protects and explains the old view under the conditions you observed.
If the session has expired, identify that separately. A sign-in prompt and a stale-record warning solve different problems. Complete the normal sign-in route only within the access already provided, then inspect whether the unsaved sample text remains available.
Also check a normal refresh before saving. The product may intentionally reload the current record and discard an untouched old view. That does not excuse losing new text without the protection your product promises. State exactly what had been typed before the refresh.
Give a founder peer a small, reproducible task
A public request should specify the fixture, account context and action order. For example: “Using this sample task, open two tabs. Save a description in A, then a title in B. Tell me which title and description appear after reopening the record.”
Share safe credentials or access only through the product's intended test arrangement. Do not publish a real customer's record or invite peers to experiment with live work. A fictional fixture makes the expected changes easier to compare too.
On Buildside, a founder can share the prototype and a focused question about the work. Ask peers to report what happened rather than approve the interface in general. Relevant feedback may come from someone who regularly keeps several work tabs open.
Provide the expected behavior and the limits of the request. This review concerns one account and a stale record. It does not cover role boundaries, every network failure or simultaneous collaboration across devices.
Report the final record, not just the toast
A useful result includes the initial values, edits made, save order, visible message and final reopened values. If text disappeared, identify which field and which action preceded the loss. Keep a screenshot or recording free of private information.
After a repair, repeat the failed sequence with the same sample data. Then repeat the reverse order and the same-field case, since the remedy may treat those paths differently. Share the revised behavior and invite one bounded recheck.
When documenting the release publicly, say which paths were checked and what remains untested. “Both edits survived this two-tab sequence” is an inspectable observation. “We solved collaboration” is much broader. The useful public record shows how someone can keep working when an older tab meets a newer saved record.
Hey I'm Uriel Bitton. I write about building in public strategies and growing startups.
Subscribe for more stories on growing your audience by building in public.
Join us on Buildside: the social network for founders building in public.
Top comments (0)