011 min
The problem progressive loading solves
Before 2010, Facebook's home page was built the traditional way. The server collected every part of the page, assembled one complete document, and only then sent it to the browser. While the server worked, the browser sat idle with nothing to draw. Once the page arrived, the roles reversed: the browser had all the work, and the server could no longer help.
One slow database query held back everything. The news feed, the navigation bar and the friend suggestions all waited for the slowest piece, because nothing was sent until everything was ready. The time before the first byte arrives, the latency of the request, was spent on a blank white screen.
A blank screen gives no sign that anything is happening. A short wait looks like a broken page, and on slow mobile connections some visitors leave before the page appears at all.
Progressive loading is the design answer. Instead of one large delivery at the end, the page arrives in pieces, and the most useful piece comes first. The idea is easy to state. The decisions it forces are harder. Which piece goes first? What fills the gaps? And what happens when a late piece pushes the early ones around?
022 min
How progressive loading works
Progressive loading changes the order of delivery, not the amount delivered. IBM's Carbon Design System describes it as loading a page in batches: the simplest view comes first, followed by more detailed batches until the whole screen is filled.
Each batch has its own job:
- First batch: the page's frame and its text. Headings, navigation, labels and the words a person came to read. Areas that will hold data show a grey placeholder shape, called a skeleton state.
- Later batches: images, content below the visible part of the screen, buttons and controls that depend on data, and extras such as recommendations or analytics scripts.
- Several slow sources: each source fills its own area when its data is ready, so the slowest source does not hold up the rest.
Why showing part of a page early feels faster
The total load time often barely moves. What moves is the moment a person can start. Jakob Nielsen put the limit at about one second: a delay shorter than that is noticed, but it does not break a person's line of thought. His second limit is about ten seconds. After that, people stop watching the screen and turn to something else. Nielsen wrote these limits down in his 1993 book Usability Engineering, building on Robert Miller's 1968 research on computer response times.
A first batch that lands inside one second keeps the person in their task. They read the headline while the photo is still on its way. Time spent reading is active waiting, because the person is doing something. Time spent watching a spinner is passive waiting, and passive waiting feels longer. That is the gap between actual speed, which a stopwatch measures, and perceived speed, which a person reports.
031 min
Where progressive loading comes from
Progressive loading has no single inventor. It is practitioner convention that grew out of several separate pieces of work.
- The timing limits: Robert Miller's 1968 study of response times, made widely known by Nielsen in 1993.
- The file formats: progressive JPEG files and interlaced PNG and GIF files can be drawn in rough passes before the download ends.
- The server: Facebook's BigPipe, described by the engineer Changhao Jiang in 2010, sent a page in independent pieces.
- The placeholder: in 2013 the designer Luke Wroblewski described replacing spinners with empty page outlines that filled in as content arrived. That pattern is now called the skeleton screen.
- The rules: design systems such as IBM's Carbon later wrote down which content belongs in the first batch and which can wait.
So when a vendor or a blog credits one person with progressive loading, read it as shorthand. The name describes a shared habit of the web, not a single discovery.
042 min
How Facebook used progressive loading on the server
Facebook's fix for its blank home page was called BigPipe. Changhao Jiang's 2010 BigPipe design split each page into small pieces called pagelets and moved them through the server and browser in a pipeline. The home page became a set of pagelets: the navigation, the composer where people write posts, the news feed, friend suggestions and ads.
The server first sent a short, unfinished page. It held the layout and one empty slot for each pagelet. Then the server kept the connection open. As each pagelet's data came back from the database, the server produced its HTML and pushed it down the same connection. The browser then placed it into its slot. When the navigation pagelet was already on screen, the news feed pagelet could still be in the making on the server.
Why the server and browser had been waiting on each other
Under the old model the work ran in strict turns. The server did its three stages first: reading the request, fetching data and writing the markup. Only then did the browser start its four: downloading style sheets, building and styling the page, downloading scripts and running them. Each side waited for the other to finish. BigPipe borrowed the idea of a pipeline from computer processors, where different instructions sit in different stages at the same time. While the browser styled the navigation, the server could still be fetching the feed. The overlap is where the saved time comes from.
Facebook measured the result instead of guessing it. Facebook loaded its home page 50 times with an empty browser cache, and BigPipe cut the latency users perceived by half in most browsers.
BigPipe needed nothing new from browsers. It ran on PHP and JavaScript alone. But it did need a page designed as separate pieces. A page whose every part depends on one slow query cannot arrive in pieces, because it has only one piece.
053 min
Progressive loading for images
Facebook later used the same idea inside a single picture. Many image files can be saved in more than one order. A baseline JPEG is stored from top to bottom at full detail, so on a slow download a sharp strip grows slowly down the screen. A progressive JPEG is stored in passes. The first pass covers the whole image at low detail, and each later pass adds detail. On a slow connection, a person sees what the picture shows almost at once and can choose to wait or scroll on.
PNG and GIF files have a similar option called interlacing. The PNG version, named Adam7, fills the image in over seven passes.
The passes have costs. Decoding an image in several passes takes more processor work than decoding it once, which means more memory and battery use on phones. File size is a mixed picture. For JPEG files the difference is usually tiny, and progressive files are often slightly smaller. Interlaced PNG files can be 30 to 40 percent larger than plain ones, so many teams skip PNG interlacing. The benefit is largest on slow or unstable connections, where a baseline image would sit half-drawn for seconds.
A related technique sends a tiny, blurred stand-in first. It is called a low-quality image placeholder, or blur-up. The stand-in is a file of a few hundred bytes that shows the image's colours and rough shapes. The real file replaces it when it arrives.
Facebook's 200-byte cover photos
In 2015, cover photos at the top of Facebook profiles were often around 100 KB after compression. On a 2G connection, that could take seconds. There was a second delay too: the app first asked the server for the photo's address, then made another request to fetch the image itself. The engineer Edward Kandrot and his team asked whether a picture could be suggested in only 200 bytes, small enough to be sent inside the first response.
They found that the blurred look they wanted needed an image only about 42 pixels wide. They removed the parts of the JPEG file that are the same for every cover photo and stored those on the phone. The phone drew the blurred preview in its very first pass and swapped in the full photo once it arrived from the server. Facebook reported that profile and page loads got 30 percent faster for people on slow connections.
Is a blurry first pass harder to read?
Not everyone agrees that coarse-then-sharp images help. One study of progressive image rendering argued that an image which starts coarse and then turns sharp makes the brain work slightly harder. When José Manuel Pérez reviewed the evidence for Smashing Magazine in 2018, it was the only study he could find. The browser engineer Yoav Weiss called it too limited to settle the question. Lab tools such as Speed Index score how fast the visible page fills in, from a filmstrip of the load, but a score is not a person's judgement. Until larger studies exist, the safe reading is narrow: progressive images clearly help on slow connections, and their benefit on fast ones is unproven.

063 min
Progressive loading in front-end code
Today the batches are usually set in front-end code rather than in a custom server system like BigPipe. MDN's guide to progressive loading states the aim plainly: delay everything you can, and load at once only what the first view needs.
- Split the bundle. One large JavaScript file blocks the first paint, because the browser has to fetch it before it can draw. Splitting code by page or feature means the first view loads only its own code.
- Unblock rendering. Style sheets and scripts in the page head stop the browser from drawing until they arrive. Marking scripts with
deferlets the HTML appear first. - Load the first screen first. Content above the fold, the part visible without scrolling, goes in the first batch. Images further down use
loading="lazy", which tells the browser to fetch them only as the reader scrolls near them. - Fetch the next step early. A page can preload what a person will probably need next. A search form, for example, can fetch parts of the results page while the person is still typing.
- Show the result before the server confirms it. Optimistic UI shows a liked post or a sent message as done at once. It corrects the screen in the rare case the request fails. This removes a wait instead of splitting it.
How React's Suspense sets the batches
In React, a Suspense boundary shows its fallback until the content inside it is ready, and nesting several boundaries creates a loading sequence. A fallback is the placeholder, often a skeleton. A designer's batch plan becomes a set of boundaries in code: one around the page, one around the results list, one around each slow side panel. Placing the boundaries is a design decision, because each one marks a place where the person will see a placeholder.
When finished content hides again
The same mechanism can work backwards. If a section that is already on screen asks for new data, its boundary can switch back to the placeholder and remove content the person was reading. React's documentation calls this experience jarring. Its fix is a transition, which keeps visible content in place while the new content loads in the background. The rule holds in any framework: a batch that has appeared should not disappear.
Lazy-loading the main image makes it slower
Lazy loading is only for what is out of view. Google's web.dev guide warns against lazy-loading any image that is likely to be visible when the page opens, especially the largest one. That image is often the biggest thing on the first screen. Delaying it pushes back Largest Contentful Paint, the metric that records when the main content looks loaded. A blanket rule to lazy-load every image is a common way progressive loading makes a page slower.
073 min
What to show while progressive loading fills in
Every batch except the last leaves gaps, and something has to fill them. The right filler depends mostly on how long the gap lasts. The table follows guidance from the Nielsen Norman Group, based on the timing limits Nielsen set.
| Expected wait | What to show |
|---|---|
| Under 1 second | Nothing extra. A placeholder that flashes and vanishes makes people feel they cannot keep up. |
| About 1 to 10 seconds | A skeleton screen for a full-page load, or a spinner for one component. |
| Over 10 seconds | A progress bar with an estimate of the time left, so people can decide to do something else. |
A skeleton screen fills each content area with grey shapes in the size and position of the content to come. Skeletons suit containers such as a card, a list row or a block of text. Buttons and other controls usually do not get one; they appear when they work. The Nielsen Norman Group describes three kinds: static shapes, animated shapes with a slow pulse or shimmer, and a frame-only version that shows just the header and footer. The shapes must match the real layout. A skeleton with three lines that turns into a card with six lines moves everything below it. Some design systems accept plain white space instead of a skeleton when content will arrive almost at once.
Spinners say that work is happening, but not how long it will take. Luke Wroblewski argued in 2013 that spinners can backfire, because any progress indicator draws attention to the fact that someone has to wait. In his Polar app, users wrote in that the version with spinners felt slower than the one before. His team replaced the spinners with skeletons, and with loading built into the transition to the next screen, so the page change itself covered the wait.
Two more choices complete the set. A full-screen loader blocks the whole interface, and it fits only when nothing can be used until the work ends. An inline indicator marks the one component that is busy, such as a table being filtered, and leaves the rest usable. For long lists, a "load more" button or loading on scroll keeps the first batch small.
Loading states also have to work without sight. A screen reader user needs to hear that content is loading and when it has arrived, which a live region announces. Shimmer animations should stop for people who have asked their system to reduce motion.
Skeleton screens do not always feel faster
The common reading is that skeletons always beat spinners. The evidence is weaker than that. In a 2017 test with 136 people, the design agency Viget found the skeleton screen did worst on every measure. All three versions of the wait had the same length. Yet people who saw the skeleton guessed the wait at 2.82 seconds on average, against 2.41 seconds for a spinner and 2.29 seconds for a blank screen. The researchers suggested that the skeleton was unfamiliar, so it drew more attention to the wait. The lesson is not to drop skeletons. It is that the placeholder is the smallest part of progressive loading. Real content shown early is what does the work.
082 min
When progressive loading goes wrong
Progressive loading creates a failure that a single delivery cannot have: the page changes while someone is using it.
Late content that moves the page
An image that arrives without a reserved space pushes the text below it down. A person who was about to tap a link taps an ad instead. Google measures this movement as Cumulative Layout Shift, and the first cause it lists is images without set dimensions. Google's guidance is to give every image and video a width and height, so the browser can save the space before the file arrives. The same applies to ads, embedded videos and late banners. Each batch needs an empty box of the right size waiting for it.
Hiding a slow page instead of fixing it
Progressive loading changes how a wait feels. It does not remove the wait. A page that needs eight seconds for its main content is still slow behind a perfect skeleton. The web performance consultant Tim Kadlec argues that the first job is to make the wait shorter, and only then to make the rest easier to bear.
Batches in the wrong order
If a row of ads appears before the article, and the article then pushes it aside, the first batch was the wrong batch. The order should follow what the person came for, not which server answers first. Measure the moment the main content appears, not only the moment the last file finishes.
092 min
Progressive loading vs. progressive disclosure
The nearest neighbour by name is progressive disclosure, and the two are often mixed up because both hold something back. Jakob Nielsen's 2006 definition of progressive disclosure is about moving advanced or rarely used features to a second screen. The person decides when to see them, by opening a menu or an advanced panel. Progressive loading holds content back only until it arrives. The person does not choose; the network and the server do.
The one axis that separates them is intent. Progressive disclosure delays content on purpose, to make an interface easier to learn. Progressive loading delays content only because it is not ready yet, to make the wait shorter.
| Concept | What is held back | Why | What ends the delay |
|---|---|---|---|
| This pageProgressive loading | |||
| DesignProgressive disclosure | |||
| Not in the library yetLazy loading | |||
| DesignSkeleton screen |
Lazy loading is one technique inside progressive loading, and some guides, including MDN's, use the two names for the same thing. A skeleton screen is what fills the gaps between batches. The Doherty Threshold sets a much tighter response target than Nielsen's one second, which is one more reason the first batch has to be small.
102 min
Applying progressive loading to a page
Say a product designer is planning a flight search results page, where prices come from several airlines at different speeds. A useful plan has four steps, and each one is a decision.
Rank the content by what the person came for.
Here that is the search summary and the first prices. Follow the page's visual hierarchy: what is largest and highest on the page loads first. Airline logos, seat maps and hotel offers can wait.
Draw the batches before the screens.
Mark each area of the layout with its batch number. Prices from fast sources appear as soon as they arrive, and slow sources fill their own rows later. Give every late area a fixed size, and do not re-sort rows while someone is reading them.
Pick the gap filler by length.
The summary loads in under a second and needs nothing. The result rows get a skeleton. A fare check that can take longer than ten seconds gets a progress bar with an estimate.
Test on a slow connection.
Browser tools such as Chrome DevTools can slow the network to a mobile-like speed. Load the page there and watch it fill in. Delays that are invisible on office Wi-Fi decide the order that people on phones actually see.
One question decides the rest: what is the earliest moment the person can do something useful? Design the first batch to reach that moment, and check that nothing which arrives later moves it.
?3 questions
Questions people ask
Is progressive load the same as progressive overload in fitness?
Does progressive loading make the total load time shorter?
How many batches should a page load in?
§15 sources
Sources
Show all 15 sourcesHide sources
Jiang, C. (2010). BigPipe: Pipelining web pages for high performance. Engineering at Meta.
Kandrot, E. (2015). The technology behind preview photos. Engineering at Meta.
Nielsen, J. (1993). Response Times: The 3 Important Limits. Nielsen Norman Group.
IBM Carbon Design System. Loading pattern.
Wroblewski, L. (2013). Mobile Design Details: Avoid The Spinner. LukeW.
Faulkner, K., and Olvera, K. (2017). A Bone to Pick with Skeleton Screens. Viget.
Tankala, S. (2023). Skeleton Screens 101. Nielsen Norman Group.
Aleksandersen, D. (2019). Progressive JPEGs make a meaningful impact on perceived performance. Ctrl blog.
Pérez, J. M. (2018). Taking A Look At The State Of Progressive Images And User Perception. Smashing Magazine.
MDN Web Docs. js13kGames: Progressive loading.
Google web.dev. Browser-level image lazy loading for the web.
Google web.dev. Optimize Cumulative Layout Shift.
React documentation. Suspense.
Nielsen, J. (2006). Progressive Disclosure. Nielsen Norman Group.
Kadlec, T. (2020). Effective Skeleton Screens.





