2

I'm doing a study on apps' splash screen durations. Some of the apps require a long loading time before showing the content.

From your experience or study, how long does it take for a user to quit the app after staying on the splash screen? How many seconds? Imagine they have no idea what's running on the back.

  • 2
    Hmm... If you're doing a study, then you should tell us what that critical duration is when you find it out. Or am I misunderstanding your first sentence? – Ken Mohnkern Sep 6 '17 at 19:45
  • thanks for helping me to clarify the question... theoretically, i would like to know when users start to dropout. then maybe before that time, i need to display something to indicate the app is not frozen but still running to load stuff on the back. so the users will know what's going on. – Viktor Sep 6 '17 at 19:48
  • I thought the results of your study would answer your question. Or are you studying something else besides how long people can tolerate a splash screen? – Ken Mohnkern Sep 6 '17 at 21:13
2

Norman-Nielsen suggest 3 orders of magnitude in responsiveness:

0.1 second: Limit for users feeling that they are directly manipulating objects in the UI. For example, this is the limit from the time the user selects a column in a table until that column should highlight or otherwise give feedback that it's selected. Ideally, this would also be the response time for sorting the column — if so, users would feel that they are sorting the table. (As opposed to feeling that they are ordering the computer to do the sorting for them.)

1 second: Limit for users feeling that they are freely navigating the command space without having to unduly wait for the computer. A delay of 0.2–1.0 seconds does mean that users notice the delay and thus feel the computer is "working" on the command, as opposed to having the command be a direct effect of the users' actions. Example: If sorting a table according to the selected column can't be done in 0.1 seconds, it certainly has to be done in 1 second, or users will feel that the UI is sluggish and will lose the sense of "flow" in performing their task. For delays of more than 1 second, indicate to the user that the computer is working on the problem, for example by changing the shape of the cursor.

10 seconds: Limit for users keeping their attention on the task. Anything slower than 10 seconds needs a percent-done indicator as well as a clearly signposted way for the user to interrupt the operation. Assume that users will need to reorient themselves when they return to the UI after a delay of more than 10 seconds. Delays of longer than 10 seconds are only acceptable during natural breaks in the user's work, for example when switching tasks.

However, these are just rules of thumb, easy to remember but not particularly accurate. The goal is simply categorization of duration, so we can assign the correct type of UI feedback (nothing, spinner, progressbar, etcetera.). It is not intended as precise tool or measurement.


So, how long does it take, then?

What you're asking would be closer approximated by website bounce rate. That is, how many seconds do people let a page load before closing it deciding it is too slow.

Looking at just the first few charts on google, that time is drastically lower than 10 seconds: Bouncerate Chart from CodeProject Bouncerate Chart from instantclick.io

Bouncerate Chart from Basilic.io

On average these charts show the most significant curvature more around 6 seconds. What's also interesting to note that the first of these three shows an increased bounce rate after several years, though the timing of the bounces seems to be about the same.


Caveats Galore

Even though these charts are more precise, there are still a bunch of notes.

For one, when a page is loaded and when it is usable are two different things. If I'm clicking a link to a blog post, I can start reading before all images are loaded. If a site/app is just a static screen until it's 100% done loading, it will feel slower.

Then, there's expected duration versus actual duration; if I'm used to apps loading in 1 or 2 seconds on my phone, and yours takes 10 seconds, I will wonder if it started to hang. Some apps can get away with this better than others; if I'm starting a game, I can imagine it's a pretty big load, but if opening your camera-app takes several seconds it's not a good sign.

And of course there is a huge variety in devices and network speed. This is slightly mitigated by a user's previous experience with the device, but this doesn't account for things like our server being slow.


* ! RAMPANT SPECULATION AHEAD ! *

Perhaps 43 years ago the limit was actually 10 seconds, but a lot can happen in a lifetime.

U.S. men work 100 hours more per year than in 1970, women 230 more. The average commute has gone from 20 to 30 minutes in 40 years. We live in an on-demand society where we pay watch Dragons vs Zombies without ads, at our schedule. Our phones are orders upon orders of magnitudes faster than the fastest supercomputers of the 80's; the Cray- did 0.8 gflops for tens of millions of dollars while the iPhone 6 does 100+ gflops.

So maybe, in the almost 50 years since 1968, we have gotten a bit more impatient and 10 seconds have become 5...

1

I think the answer you are looking for is 10 seconds.

The following extract is from the article Response Times: The 3 Important Limits by Jakob Nielsen

10 seconds is about the limit for keeping the user's attention focused on the dialogue. For longer delays, users will want to perform other tasks while waiting for the computer to finish, so they should be given feedback indicating when the computer expects to be done. Feedback during the delay is especially important if the response time is likely to be highly variable, since users will then not know what to expect.

  • I feel like 10 seconds is way too long. Practically, having to stare at the very first screen of an application isn't ideal. I feel like 3-5 seconds would be more practical. Not to mention that users are usually in a hurry and tend to get restless if there's no response/change on a screen after an action – Shreyas Tripathy Sep 7 '17 at 5:20
  • @ShreyasTripathy you must not confuse your response with that of the average user. Designers are far from typical users. The article is based on reasearch (references are listed at the end of the article). However it is very importand to give some feedback during this period, if no real progress can be given, a simple animation will do the job. – DesignerAnalyst Sep 7 '17 at 5:30
  • the Nielsen article above links to nngroup.com/articles/website-response-times which says "A 10-second delay will often make users leave a site immediately. And even if they stay, it's harder for them to understand what's going on, making it less likely that they'll succeed in any difficult tasks." – Stephen Lead Sep 7 '17 at 5:41
  • If you look at all 3 mentioned limits, you'll notice they're all order of magnitudes. 10 seconds isn't a specific breakpoint, it's an indication of what kind of breakpoint is measured in seconds. – PixelSnader Sep 7 '17 at 7:11
1

I agree with @DesignerAnalyst and the reference of NN Groups article on Response time is one of the best references for this. Apart from that, Viktor, you could utilise this time to show details about product info or any such facts or trivia relevant to your product. If you would have noticed, when a user installs MS Windows, which obviously takes time, there are many relevant info given to users during this time along with showing the progress of installation. Providing the feedback on the Loading progress to the user is key here. The chances of user dropping off could decrease if they are informed or at least given an idea of how sooner the load task will be completed.

  • Your suggestion probably extents the 10 seconds limit, since users will be occupied with other info . – DesignerAnalyst Sep 7 '17 at 5:50

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

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