Research question
When does a completion message provide enough evidence for a person to act next without compromising the intended outcome?
Method
A focused discussion of HCI literature connects feedback, closure, synchronisation, recovery and task resumption. Three explicitly constructed contrasts distinguish process milestones, outcome evidence and the actions that a completion claim warrants.
Key findings
- Constructed cases
- 3
- Proposed ambiguity test
- 1
- Human studies
- 0
- Completion is action-relative: a local save can justify closing an editor without establishing that an offline tablet has the latest version.
- When visually equivalent states require incompatible next actions, the interface must distinguish them, make the action safe across them, or communicate uncertainty.
Limitations
This is a theoretical contribution based on selected literature and constructed examples, not a user study or validated usability guideline. The journal records 15 Nov 2026 as the submission date; submission was completed on 16 Nov Beijing time.
Full manuscript
Web reading edition of the submitted manuscript, including text, original figures, tables and references.
Abstract
Completion messages in asynchronous interfaces can be technically correct yet inadequate for deciding what to do next. A file may be saved locally but unavailable on another device; an upload may have reached a server without producing a receipt visible to its sender. This theoretical paper examines completion as a relationship between feedback, a particular version of an artefact, and a subsequent user action. A focused discussion of human–computer interaction research on progress, closure, synchronisation, recovery, and task resumption motivates an action-relative account. The account distinguishes a process milestone, evidence about its outcome, and the actions that this evidence warrants under stated assumptions. An ambiguity test identifies feedback that represents states requiring incompatible next actions as equivalent. Three constructed examples apply the test to saving, media export, and uncertain upload outcomes. They demonstrate analytical distinctions, not observed user benefits. The resulting design guidance concerns scoped completion messages, recoverable outcomes, and access to evidence after interruption. A proposed evaluation programme separates technical soundness, comprehension, decision quality, and perceived reassurance. The contribution is a bounded method for examining completion feedback without equating a reassuring display with successful human–computer coordination.
Keywords
Interaction design; Human computer interaction; User interface design; Completion feedback; Asynchronous interaction; Error recovery
1 Introduction
A person finishes editing a document, sees a checkmark, and shuts a laptop. What has the interface said? Perhaps the latest edits have reached local storage. Perhaps they have reached a server. Perhaps the checkmark describes a previous version while a new one remains in a queue. These interpretations need not matter when the person intends to reopen the same file on the same device. They matter when the next task is to open it elsewhere, remove the local copy, or let a collaborator continue. A completion display therefore does more than describe elapsed work. It helps organise a transition between activities.
This paper asks how completion feedback should be analysed when processing, persistence, propagation, and user attention do not end together. Its central claim is that the adequacy of a completion message depends on the next action it can reasonably support. A display can accurately report one milestone and still fail to support a decision that the surrounding interaction invites. Conversely, an operation need not finish every background step before the user can safely leave it. The design problem is to expose the distinctions that matter for a particular transition, while keeping irrelevant implementation detail out of the interaction.
The familiar principles of informative feedback and dialogue closure provide a starting point. Shneiderman's account connects completion feedback to releasing contingency plans and preparing for subsequent activity (Shneiderman, n.d.). That connection makes closure consequential: relief is useful when the work it allows the user to stop monitoring has reached an appropriate condition. Harley's discussion of system-status visibility similarly connects feedback to a user's ability to decide what to do next (Harley, 2018). Neither principle requires exhaustive displays of internal state. The question pursued here is how to determine which differences between states are relevant enough to disclose.
The scope is ordinary asynchronous operations that produce or update a digital artefact: saving, exporting, uploading, and synchronising. Here, asynchronous means that an initiating action and its relevant outcomes are separated in time, possibly across devices or services. The argument does not concern conversational turn-taking or general acceptance of technology. It addresses interaction at the boundary between an action that appears finished and a later action whose success depends on what actually finished.
The paper makes three contributions. First, it defines action-relative completion as an analytical relationship among an identified outcome, available evidence, and a subsequent action. Second, it develops an ambiguity test for identifying displays that collapse distinctions needed for different actions. Third, it derives a design and evaluation agenda that separates warranted decisions from reassurance. Three constructed examples make the reasoning inspectable. They are not observations of particular applications, user studies, or measurements of failure prevalence. The proposed account requires empirical evaluation before its interface recommendations can be treated as validated guidelines.
2 Positioning the argument in HCI
2.1 Approach and evidential boundaries
This is a theoretical short paper informed by purposively selected literature, not a systematic review or a functionality review of products. Directed web searches and reference-led retrieval on 14 November 2026 sought work on progress indicators, synchronisation models, post-completion errors, undo, closure, and task-resumption cues. Searches included combinations of “progress indicators” and “task completion”, “file synchronisation” and “user models”, and the titles of relevant primary papers. Publisher records and author-hosted papers were used to check the claims discussed here. Supplement S1 records the sources, the parts consulted, and the limited role of each source in the argument.
The selection aims to establish relevant distinctions and counterarguments, not to estimate the distribution of interface practices or identify every prior account of completion. It has no preregistered protocol, database-wide screening, independent coding, or claim to search saturation. Hossain et al. (2025) distinguish the aims and methods of functionality reviews in HCI; their methodological discussion underscores why the constructed examples below should not be read as evidence about a sampled population of products. The present contribution is assessed through explicit definitions, counterexamples, and the traceability of design implications to the argument.
OpenAI Codex was used to assist literature discovery, draft the text and analytical examples, develop the proposed synthesis, generate the original diagram, and check bibliographic details. These activities were AI-assisted rather than independent human coding. No simulated participant responses or empirical results are reported.
2.2 Progress and the interpretation of an endpoint
Harrison et al. (2007) compared the perceived duration of different progress-bar behaviours while holding duration at 5.5 seconds. Their study demonstrates that the behaviour of a progress display can alter experienced speed. Its limits are equally relevant: it does not establish which persistence or access guarantees a completed display communicates. The authors also distinguish processes for which accurate, stable progress can already be shown from less predictable processes for which perceptual adjustments might help. Perceptual findings should therefore not be interpreted as permission to conceal an unresolved outcome.
Conrad et al. (2010), writing in this journal, report two experiments on progress feedback during online questionnaires. Their findings link the pattern of feedback to experience and abandonment, with discouraging early progress sometimes harming completion. Questionnaire completion, however, concerns the person's progress through an activity; it is not equivalent to the durable availability of an artefact after background processing. Together these studies support a distinction between experienced progress and the conditions under which a subsequent action is justified. This distinction does not dispute the value of perceptual design. It identifies a further outcome that perceived waiting time alone cannot measure.
Hurter et al. (2011) explored active progress bars that help users switch to temporary activities during waits. Their participatory work, survey, and prototype shift attention from watching a process to coordinating other activities around it. That shift raises a completion problem: feedback may arrive while the person is elsewhere. A temporary notification can announce an event without leaving enough information to interpret the result on return. The possibility motivates the persistent evidence proposed below; the proposal is not a reported result of their study.
2.3 Persistence and propagation are different accomplishments
Marshall and Tang (2012) examined cloud file services through a survey of 106 people and 19 interviews. They identified different conceptual understandings of repositories, replicated stores, and synchronisation. Their design discussion explicitly addresses uncertainty about when synchronisation occurs or finishes, and the consequences of actions that interrupt it. This is direct precedent for making process boundaries intelligible. Their study concerns early services and adopters, so it should not be used as a current prevalence estimate or as a description of today's implementations.
Local-first software provides a useful counterweight to an overly cautious interpretation of that precedent. Kleppmann et al. (2019) describe software that preserves local agency and allows work without a network, while supporting later collaboration. Under such an architecture, the fact that synchronisation remains pending does not by itself mean that closing a view or continuing locally is unsafe. A single completion threshold for every next action would erase this benefit. The analytical task is to separate what can already be done from what still depends on propagation, without promising universal durability from a single acknowledgement.
2.4 Recovery and returning to a task
Abowd and Dix (1992) treat undo as an intention requiring support, rather than merely a command whose implementation must be specified. Their analysis of shared editing distinguishes system-level reversibility from what users want to recover. This distinction matters when an asynchronous operation fails only partly: repeating a command, restoring a version, locating an already-created result, and abandoning a pending transfer are different recovery actions. A generic retry button cannot be assumed to support all of them.
Li et al. (2005) demonstrate post-completion errors in problem-solving tasks and report that a static cue reduced, but did not eliminate, such errors. Their work concerns omitted actions after a main goal; it does not establish how often premature completion messages cause data loss. It nevertheless provides a reason to examine whether an interface makes a remaining obligation appear peripheral. The proposal here is to make a required next step part of the represented outcome, rather than to infer a particular psychological effect without testing it.
Evidence on resumption also cautions against assuming that additional cues automatically improve performance. Schneegass et al. (2022) report mobile-learning studies in which participants valued cues, but the initial laboratory study did not show significant effects on objective completion time or error rate. The domain differs from saving and uploading. The relevant methodological lesson is that perceived helpfulness and measured benefit should be distinguished. This paper accordingly treats reassurance, comprehension, and action choice as separate evaluation targets.
3 An action-relative account of completion
3.1 Outcome, evidence, and action
Consider a target outcome g: a specified version of an artefact should remain available in a specified place, for a specified purpose. The purpose might be reopening a document locally, playing an exported file from a destination folder, or handing the latest version to a collaborator. It is intentionally narrower than an absolute claim that data will never be lost. Let a denote the proposed next action, such as closing the editor, disconnecting the network, deleting a source, retrying a submission, or opening the artefact on another device.
Three things must be kept separate. A milestone is an event in processing, such as finishing encoding. Evidence is information available to the interface about an outcome, such as a successful destination write acknowledgement. A completion claim is what the interface communicates through wording, placement, timing, and available controls. The interface may have better evidence than it shows; it may also display a stronger claim than its evidence supports. Either mismatch can matter for interaction.
Evidence must be tied to an artefact and version. “Saved” beside a document can become stale after another edit. An acknowledgement that correctly refers to version v1 cannot establish that v2 has propagated. Likewise, a timestamp for opening a status panel is not necessarily a timestamp for the last successful write. The account therefore treats identity, version, destination, and the time or condition of observation as part of the scope of a claim. These fields need not all be visible all the time. They must be available wherever their omission permits incompatible interpretations relevant to the user's next action.
The word safe is used in a restricted sense: the action preserves the specified target outcome under declared assumptions. It does not mean that an application is certified, that storage is infallible, or that every future action is harmless. A design might assume functioning local storage, a persistent retry queue, and no later deletion by another actor. Those assumptions should be tested where possible and narrowed where they cannot be established. The analysis is useful only when the target and assumptions can be stated precisely enough to challenge.
3.2 The ambiguity test
Let B(m,c) be the set of materially different system states consistent with the information provided by message m in interaction context c. The context includes visible history and relevant surrounding controls, not just a single word. B is an analyst's ambiguity set; it is not a measured model of a person's beliefs. For each state s, define P(s,a,g) to mean that performing a preserves target g under the stated operating assumptions. A message warrants a without further checking only when P holds for every state in B(m,c).
The practical test is straightforward. Identify two plausible states that the interface represents equivalently. Ask whether the same next action preserves the target in both. If it does not, the display cannot, on that information alone, support a reliable distinction between proceeding and waiting. Either the interface must distinguish the states, the action must be made safe across them, or the uncertainty must remain explicit. This is an analytical necessity under the chosen state descriptions, not an empirical prediction that every user will make an error.
The test also prevents an indiscriminate demand for transparency. States may differ internally yet permit all the same relevant actions. Exposing those differences would add detail without resolving a decision. Conversely, adding a spinner or a longer explanation does not resolve ambiguity if neither distinguishes the outcome that matters. The goal is a useful partition of states by their implications for action, rather than maximum visibility of all processing.
3.3 What the account adds and what it does not
The account does not replace status visibility, closure, or recovery. It supplies a way of deciding what those principles should expose at a transition. Its unit of analysis is the relationship between a claim and an action, rather than the presence of a particular widget. A notification can be adequate for one action and inadequate for another. An interface can also be adequate without any extra message if the action itself is constrained so that the outcome is preserved.
There are three independent questions. Is the communicated claim supported by the system's evidence? Is its scope intelligible to the person using it? Does acting on it preserve the intended outcome? A technically truthful label can fail the second question. A comprehensible label can fail the first. A reassuring label may pass neither. These distinctions explain why backend verification, interface interpretation, and observed behaviour require different forms of evaluation.

Figure 1. The analytical path from a process event to an action-relative completion claim. This is a conceptual diagram, not an empirical result. A claim requires both evidence and an intelligible relationship to the intended next action.
4 Constructed contrasts
The following examples are deliberately constructed to expose differences in outcome and action. They do not describe audits of named products or reproduce project test records. Each specifies a target, relevant assumptions, and a pair or sequence of states. Table 1 summarises the conflicts. Their value lies in making the account refutable: a reader can dispute an assumption, show that a state is impossible in an implementation, or demonstrate that the proposed action is safe in both states.
Table 1. Constructed contrasts and the ambiguity each exposes.
| Case and target | States represented alike | Decision that distinguishes them |
|---|---|---|
| Saving Use v2 on an offline tablet | S1: v2 only on laptop S2: v2 also stored on tablet | Continue on tablet. Closing the editor may still be safe in both states if local persistence and its queue survive. |
| Export Retain the intended destination copy | E1: temporary preview only E2: destination copy committed | Delete source. A playable preview alone does not establish that this preserves the target. |
| Upload Create one record | U1: record created; response lost U2: record not created | Retry. An unqualified retry is unsafe if repeated requests can create duplicates. |
4.1 A document saved here but not available there
Assume an editor durably stores version v2 on a laptop and has queued a synchronisation operation. Its window displays “Saved”. The person intends to present v2 from a tablet without bringing the laptop. In state S1, v2 is only on the laptop; in S2, the tablet has a locally available copy of v2. For the action “open v2 on the tablet while offline”, S1 and S2 have incompatible implications. The same unqualified display leaves the relevant boundary unresolved.
Now change the action while holding the states fixed. If closing the editor preserves the local copy and the persistent queue, closing may be acceptable in both S1 and S2. Disabling the close control until all devices synchronise would be an unnecessarily restrictive response. A better representation can distinguish local availability from cross-device availability while allowing unrelated activity to continue. For example, “Saved on this laptop; tablet copy not confirmed” describes the scope of evidence. It does not require the user to understand replication protocols.
Nor is a server acknowledgement necessarily evidence that the tablet is ready offline. The server and target device are different destinations. If the interface cannot establish the latter condition, it should not infer it from the former. An action such as “Check on tablet” may be more honest than a universal green checkmark, provided the interface does not treat the absence of confirmation as proof of failure. The case demonstrates that completion can be sufficient for leaving one view but insufficient for continuing at a different location.
4.2 An export whose preview outlives its source
Assume a media editor can play a temporary preview before the final file is committed to a user-selected destination. A person intends to remove the source material after exporting a shareable copy. State E1 contains a playable temporary preview with no committed destination file; state E2 contains the intended exported version in the destination. If both produce an unqualified completion banner beside an enabled “Delete source” action, the interface supports a consequential inference that E1 does not warrant.
An appropriate response depends on the product's actual guarantees. The application might retain the source automatically until destination persistence is confirmed. It might explicitly separate “Preview ready” from “Export saved”, then offer a link to the resulting artefact. If it cannot verify persistence, it can retain the source and disclose the uncertainty. Merely changing the banner colour does not establish the missing condition. Equally, the ability to play a preview is not proof that the intended export is complete or that every frame and audio sample is correct.
This example exposes the limits of a verification affordance. “Open exported file” can help a person locate and inspect an outcome, but its presence is not a guarantee of semantic correctness. The displayed duration, filename, or thumbnail must refer to the exported artefact, not to the temporary preview. The target may require further checks, such as whether the exported version includes the intended audio. Those checks are distinct from persistence and should not be silently implied by a storage acknowledgement.
4.3 An upload with an uncertain acknowledgement
Assume a form submission creates a new server record. After transmission, the client loses its connection before receiving the response. In state U1, the server created the record; in U2, it did not. The client has the same observable timeout in both states. If a second submission can create a duplicate, labelling the timeout “Failed” and encouraging an immediate retry is not supported by the available evidence.
This is not solved by waiting for a more emphatic completion message. The interface needs either additional evidence or a recovery action that is safe across the uncertainty. A status lookup tied to a submission identifier could establish whether the original record exists. A retry could be safe if the server reliably treats the same request identifier as the same operation. Where neither mechanism exists, the interface should communicate the uncertain outcome and provide a way to reconcile it. The account does not assume that such infrastructure is always available.
The example also distinguishes stopping observation from reversing an effect. Closing the upload window does not necessarily cancel server processing. A control labelled “Cancel” can therefore imply a stronger operation than it performs. If it merely stops waiting, its wording and subsequent status should preserve that distinction. Recovery is about the user's intended outcome, not just about removing the current interface state. A persistent receipt, when available, can support later reconciliation more effectively than an ephemeral success animation.
5 Implications for design
5.1 State the boundary of the accomplishment
A completion message should identify the boundary it actually establishes when that boundary changes what a person can do next. Local save, remote receipt, target-device availability, and successful opening are different boundaries. A compact default message may suffice when the surrounding context makes the boundary clear. Where it does not, a short qualifier can be more useful than a larger progress display. The proposed examples are design candidates, not experimentally optimised wording.
The account favours progressive disclosure tied to decisions. A person continuing to edit locally need not inspect a replication log. A person attempting to remove the only confirmed local copy needs more information. The same underlying evidence can support a modest status indicator in one context and a more explicit intervention at a consequential action. This shifts the design question from how much information to show globally to where a distinction becomes necessary.
5.2 Preserve outcomes instead of demanding vigilance
The strongest resolution of ambiguity may be to change the action rather than its description. Keeping an original until an export is confirmed, persisting a retry queue, or making a repeated request non-duplicating can permit a wider range of next actions. Such mechanisms are not substitutes for communication: people still need to understand what happened. But they avoid making continuous monitoring the condition of successful use.
A warning that asks a user to remember every hidden dependency transfers coordination work to that user. The proposed account instead asks what the system can preserve automatically and which residual decisions genuinely require attention. Where a constraint is imposed, it should match the specific dependency. Blocking all interaction because one optional transfer is pending is different from protecting an irreplaceable source whose export has not been established.
5.3 Make completion inspectable after attention has moved
An event notification and a record of an outcome have different functions. The former attracts attention at a moment; the latter allows interpretation later. An asynchronous interface should consider what evidence remains after the notification disappears, the application restarts, or the user returns from another task. A compact record can identify the version, destination, unresolved obligation, and available recovery action. It need not preserve every internal event.
Persistent evidence has costs. It can clutter an interface, expose private filenames or recipients, and leave misleading records if versions change. A status history therefore needs a retention policy, appropriate access controls, and a distinction between historical and current state. Expanding a history is not automatically a better interaction. The test is whether it resolves an ambiguity relevant to the returning person's action, at a tolerable cost.
5.4 Represent uncertainty without implying failure
Pending, failed, and unknown are different claims. Pending indicates that completion has not yet been established while work is expected to continue. Failed indicates evidence of a failure at a specified boundary. Unknown indicates that the observer cannot distinguish outcomes. In the upload example, a timeout may establish a communication failure without establishing failure of the underlying operation. The wording should preserve that separation.
There is a corresponding distinction between retry, resume, reconcile, and discard. Retry repeats a request; resume continues recoverable work; reconcile determines or resolves which outcome occurred; discard abandons an artefact or obligation. A design should not offer these as interchangeable ways to clear an error panel. The available action should be justified by what is known about the outcome and by what the user intends to preserve.
Table 2. Questions for analysing a completion claim. These are proposed analytical questions, not validated evaluation items.
| Question | Evidence or design consequence |
|---|---|
| What exactly is claimed? | Identify artefact, version, destination, and the accomplishment represented. |
| What supports the claim? | Identify the observed acknowledgement or condition and its limits. |
| Which action follows? | Specify the next action and the target it should preserve. |
| Which states remain ambiguous? | Construct a plausible pair consistent with the visible information. |
| Does that ambiguity matter? | Check whether the action has incompatible implications across the pair. |
| Can the system preserve the outcome? | Prefer a safe action or recoverable result where feasible; disclose residual uncertainty. |
| What survives interruption? | Ensure later access to appropriately scoped evidence and recovery. |
6 Evaluating the account
6.1 Technical and interpretive validity
Evaluation should first establish whether the proposed messages are technically supportable. For each relevant version and destination, an instrumented prototype can record when a request is accepted, when an outcome is persisted, and when its status is displayed. Controlled delays, lost acknowledgements, and partial failures can then test whether a completion claim appears before its stated condition holds. This would evaluate implementation soundness under the tested conditions, not user comprehension or universal reliability.
A separate study should ask what people believe they can do after seeing the feedback. A useful task would present a specific goal and require a consequential choice: close the view, disconnect, continue on another device, remove the source, or inspect the result. The baseline should be a competent existing design with accurate status feedback, not an artificially silent or misleading interface. Comparisons could hold timing and backend behaviour constant while varying whether feedback identifies its scope and offers access to evidence.
Interpretation matters more than simple recall of a status phrase. A participant who repeats “saved locally” but assumes that an offline tablet is ready has not understood the relevant implication. Conversely, a person may choose correctly without using the designer's terminology. Behavioural choices, explanations, and the actual state at the time of choice should therefore be analysed together. Any human study would require appropriate institutional ethics review and consent before recruitment; no such study is reported here.
6.2 Outcomes that should remain separate
At least four outcome classes are needed: accurate discrimination between states, choices that preserve the specified goal, time and effort spent checking, and subjective reassurance. More reassurance alongside more premature actions would be an adverse result, not a usability improvement. Fewer errors accompanied by burdensome mandatory checking would reveal a trade-off. Reporting only task time or a global satisfaction score would obscure both possibilities.
False caution also deserves measurement. If a design causes people to wait for remote propagation when local completion is sufficient, it may be truthful yet inefficient. Evaluation should therefore include tasks where continuing is appropriate and tasks where waiting is necessary. It should report both premature action and unnecessary delay. The goal is calibrated transition between activities, rather than maximising waiting or confidence.
6.3 Research questions and possible disconfirmation
One testable question is whether naming the scope of completion improves decisions across different destinations without requiring more status checking. Another is whether persistent outcome records help after interruption more than they help during continuous attention. A third is whether action-specific intervention reduces error more efficiently than presenting all state details continuously. These are proposed comparisons, not hypotheses for which results are already available.
The account could prove unhelpful in several ways. Analysts may disagree about relevant goals so extensively that the ambiguity test is unreliable in practice. People may infer scope accurately from established conventions, making additional qualifiers redundant. Richer status records may increase confusion or privacy concerns. An implementation might preserve the desired outcome across all relevant next actions, leaving no meaningful ambiguity to disclose. These possibilities should be treated as substantive findings that bound or challenge the proposal.
7 Limitations and scope
The argument is based on selected literature and constructed examples. It offers no representative account of current products, no effect-size estimate, and no evidence that the suggested wording improves use. Search selection was purposive and conducted by one analytical workflow; relevant studies and alternative theories may have been missed. The evidence register permits inspection of the literature basis but does not substitute for systematic coverage or independent synthesis.
The ambiguity set depends on how an analyst describes states and tasks. Omitting a feasible failure can make a message appear more informative than it is; including every imaginable catastrophe makes no action warrantable. The useful boundary is the set of materially plausible states under declared operating assumptions. This boundary should be negotiated with people who understand both the implementation and the practice of use. The present paper does not validate that negotiation method.
Completion also depends on social agreements. A server may hold a document that a collaborator has not read, or a submission may have a receipt without being accepted. These are different accomplishments. The account can help expose the distinction, but it cannot determine what counts as fulfilment for every collaborative practice. Nor does the analytical condition model attention, literacy, accessibility, habituation, or the interpretation of icons across contexts. Those are necessary subjects for empirical work.
Finally, a narrow storage guarantee is not a guarantee of content quality, legal validity, or long-term preservation. The examples concern specified artefacts, versions, destinations, and next actions. Applying the account to medical, financial, or other safety-critical systems would require additional domain analysis and assurance. Its present contribution is a method for reasoning about ordinary interaction transitions, not a certification procedure.
8 Conclusion
Completion feedback should be assessed in relation to the action it helps a person take next. A process can finish without establishing the outcome that action requires; an outcome can also be secure enough for one action while further processing remains necessary for another. Distinguishing milestones, evidence, and claims makes this tension explicit.
The proposed ambiguity test asks whether states represented equivalently require different next actions to preserve a specified goal. When they do, an interface must resolve the distinction, make the action safe across it, or preserve the uncertainty. This provides a bounded extension of established HCI concerns with feedback, closure, and recovery. Its practical value and cognitive costs remain to be evaluated. The appropriate goal is not a more convincing signal that work is done, but better-supported decisions about what can happen next.
Data availability statement
No participant data were collected or analysed for this theoretical paper. The constructed examples and analytical assumptions are provided in the manuscript. Supplement S1 contains the source evidence register, selection notes, and a reusable analysis worksheet. The cited publications remain available through their respective publishers or repositories; their full texts are not redistributed in the supplement.
References
Abowd, G. D., & Dix, A. J. (1992). Giving undo attention. Interacting with Computers, 4(3), 317–342. https://doi.org/10.1016/0953-5438(92)90021-7
Conrad, F. G., Couper, M. P., Tourangeau, R., & Peytchev, A. (2010). The impact of progress indicators on task completion. Interacting with Computers, 22(5), 417–427. https://doi.org/10.1016/j.intcom.2010.03.001
Harley, A. (2018, June 3). Visibility of system status. Nielsen Norman Group. https://www.nngroup.com/articles/visibility-system-status/
Harrison, C., Amento, B., Kuznetsov, S., & Bell, R. (2007). Rethinking the progress bar. Proceedings of the 20th Annual ACM Symposium on User Interface Software and Technology, 115–118. https://doi.org/10.1145/1294211.1294231
Hossain, E., Ahmetoglu, Y., Chen, S., Dowthwaite, A., Lascau, L., Mella, J., Stern, N., & Cox, A. L. (2025). Mapping the landscape of functionality reviews in HCI: Trends, methods, and contributions. Interacting with Computers, iwaf027. https://doi.org/10.1093/iwc/iwaf027
Hurter, C., Girouard, A., Riche, N., & Plaisant, C. (2011). Active progress bars: Facilitating the switch to temporary activities. CHI '11 Extended Abstracts on Human Factors in Computing Systems, 1963–1968. https://doi.org/10.1145/1979742.1979883
Kleppmann, M., Wiggins, A., van Hardenberg, P., & McGranaghan, M. (2019). Local-first software: You own your data, in spite of the cloud. Proceedings of the 2019 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software, 154–178. https://doi.org/10.1145/3359591.3359737
Li, S. Y. W., Blandford, A., Cairns, P., & Young, R. M. (2005). Post-completion errors in problem solving. Proceedings of the 27th Annual Conference of the Cognitive Science Society, 1278–1283. https://escholarship.org/uc/item/9v74f217
Marshall, C., & Tang, J. C. (2012). That syncing feeling: Early user experiences with the cloud. Proceedings of the Designing Interactive Systems Conference, 544–553. https://doi.org/10.1145/2317956.2318038
Schneegass, C., Füseschi, V., Konevych, V., & Draxler, F. (2022). Investigating the use of task resumption cues to support learning in interruption-prone environments. Multimodal Technologies and Interaction, 6(1), 2. https://doi.org/10.3390/mti6010002
Shneiderman, B. (n.d.). The eight golden rules of interface design. University of Maryland. Retrieved November 14, 2026, from https://www.cs.umd.edu/users/ben/goldenrules.html