I am a developer of a mobile app and have no particular proficiency in UX. In my app there is a use case where the user has to wait and the progress is shown in a list with an indicator icon [check mark (done), spinning circle (in progress), empty circle(to do), cross (error)] like this:

(✔) first step is done

(✳) second step in progress

( ) third step to do

( ) fourth step to do

Each of the steps might fail but most errors are recoverable so each step is retried several times. Now I have the problem that a failing of step 3 requires me to re-execute step 2 as well. (In my particular case step 2 is calculating the encrypted payload of a challenge response procedure and step 3 is the transmission of the actual data. If the transmission fails, I have to re-encrypt the data with the new challenge)

This means that the progress list jumps back a step.

What would be a good way to signal to the user what is going on? Are there alternatives to jumping back?

Edit: more context

From the comments I guess a little more context might be beneficial to answer my particular problem. My use case is a NFC communication event with an embedded system consisting of several steps. During each step, the mobile phone has to be placed exactly onto the NFC tag (The NFC antenna and thus the connection quality varies significantly for different smartphones).

In step 2, the challenge of the challenge response procedure is read. In step 3, the data (containing the response to the challenge) is written to the NFC tag.

Usually, it is not particularly relevant to the user if a reading error occurs and I can silently retry executing that step. However, for step 3, if the writing fails then the embedded system will generate a new challenge, so I have to proceed with reading the challenge (step 2) and re-encrypting the data before writing it to the tag again.

Possible solutions

I see the following scenarios, but none of them feels particularly appealing to me:

Scenario 1:

I jump back, cross the third step, and spin the progress circle of the second step. Once the second step has successfully completed, the cross in the third step becomes a spinning circle again.

Scenario 2:

I extend the progress list with two more steps inserted after the third step. An obvious disadvantage is that with up to 5 retries the list could end up with 12 progress items -> which will not fit onto the screen

Scenario 3:

Somewhat like scenario 1 but instead of the cross icon usually used for errors I use the empty circle. The problem I see here is that the user does not get any feedback that an error occurred and the progress bar jumps back without an apparent reason

  • Did the failing of step 3 happen because of the system, or the user?
    – Izquierdo
    Commented Oct 8, 2021 at 13:17
  • rather the system. In this particular case the user is writing data via NFC, and communication errors usually occur if the mobile phone is not placed exactly on the NFC tag, so one could say that the user has an influence on whether the error occurs or not, but the error is not caused by user interaction with the app
    – Aldinjo
    Commented Oct 8, 2021 at 13:22
  • 1
    How relevant is it for users to know that an error occurred? Is it maybe more relevant to know how many attempts were made? Or is it even better not to bother the user at all and let the problem silently resolve itself?
    – jazZRo
    Commented Oct 8, 2021 at 13:54
  • I don't think it is particularly relevant to the user if an error occurred during a step. However, during each step there is exactly 1 communication event happening (step 2: reading of challenge, step 3: writing of data (including response)) so there is one moment where the mobile has to be placed exactly onto the tag. Uniting step 2 + 3 would make that two critical moments in one step.
    – Aldinjo
    Commented Oct 8, 2021 at 14:04

3 Answers 3


I am wondering if it is really necessary to communicate the technical steps to the user, since the user probably only want's the app to work.

What if you do not communicate these steps but rather tell the user what to do. In my answer I assume that each step is only very short.

You could show a progress indicator (like a progressbar, filling circle or the like). If step 3 is not working (because the user does not hold the device exactly at the right spot) you could show a message explaning exactly that. Something like "Please hold your phone close to the whatever device". The progress indicator would not go further but should keep pulsating to show that there is still something going on.

This way you probably give the user enough feedback and even give the user a clou what to do.


Inspired by the comments I came up with the following solution:

  • All steps that have to be reverted / re-executed change state to "will retry" which will be indicated by a circular double arrow (e.g. an "autorenew" icon)

  • The label of such items will start with the try and the max try (e.g. 2/5 third step)

This way, the user still has an indication of the progress (the number of remaining tries is shown), knows that a recoverable error occurred and each progress step still has the property that the user can leave the step after at most one action (that is placing the mobile device accurately onto the NFC tag). And the number of steps is restricted and will fit on the screen.


Visualization with UTF8 Emojis:

(✔) First step

(✳) 2/5 Second step

(🔄) 2/5 Third step

( ) Fourth step


After reading BrunoHs answer I came up with another solution that feels best to me:

For steps where a retry is possible without jumping back, I silently to that and keep the progress indicator spinning.

If an error occurs during the critical third step I just show an error message and encourage the user to try again.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.