What Is Speed Index?
A testing tool records the page as it loads, compares each frame with the visually complete state and calculates how much of the viewport has reached its final appearance over time. Early progress lowers the score; long periods of blank or partially complete content increase it. Speed Index is reported as a time-like value, but it summarizes the full visual loading curve rather than marking one event. The result depends on the viewport, test hardware, network, browser, page content and visual-comparison method. It is a useful lab diagnostic, not a field Core Web Vital or a direct search-ranking verdict.
- Measured in a controlled page-load video
- Evaluates visual progress frame by frame
- Focuses the visible viewport
- Rewards early sustained content display
- Depends on the final visual reference frame
- Changes with device and test conditions
- Identify the exact page, asset, entity or relationship described in this section.
- Inspect the live implementation and retain the observed evidence.
- Compare the observation with the intended meaning and its primary specification.
- Correct any mismatch, then retest the live result.
- Record the accountable owner and review date.
| Question | Answer | Why it matters |
|---|---|---|
| What is measured? | Visual progress over time | Captures loading shape |
| Data source | Lab video frames | Controlled diagnosis |
| Scope | Visible viewport | Device dependent |
| Output | Time-like score | Lower is faster |
| Single element? | No | Whole view contributes |
| Core Web Vital? | No | Diagnostic metric |
Primary specification: Chrome Lighthouse Speed Index documentation.
Speed Index is most useful when the visual progress curve is connected to the resources and rendering work responsible for incomplete frames.
What Is a Good Speed Index Score?
The mobile and desktop ranges differ because device and audit profiles differ. Treat them as tool-specific score guidance rather than universal field thresholds. Lighthouse desktop marks 0–1.3 seconds as fast, 1.3–2.3 seconds as moderate and above 2.3 seconds as slow in its documented profile. Keep tool and version consistent before comparing releases. One score can also hide different visual paths: a page that jumps from blank to complete may match the total of a page that displays stable useful content progressively. Inspect filmstrips and progress curves alongside the number. Validate later content, stability and interaction rather than chasing color alone.
- Mobile fast: 0–3.4 seconds
- Mobile moderate: 3.4–5.8 seconds
- Mobile slow: above 5.8 seconds
- Desktop fast: 0–1.3 seconds
- Desktop moderate: 1.3–2.3 seconds
- Desktop slow: above 2.3 seconds
- Identify the exact page, asset, entity or relationship described in this section.
- Inspect the live implementation and retain the observed evidence.
- Compare the observation with the intended meaning and its primary specification.
- Correct any mismatch, then retest the live result.
- Record the accountable owner and review date.
| Profile | Fast | Moderate | Slow |
|---|---|---|---|
| Mobile | 0–3.4 s | 3.4–5.8 s | > 5.8 s |
| Desktop | 0–1.3 s | 1.3–2.3 s | > 2.3 s |
| Custom hardware | Rebaseline consistently | Compare like with like | Do not reuse defaults |
| Route suite | Track median and variance | Inspect template outliers | Fix shared causes |
Use Speed Index ranges only inside a stable testing contract and let visual evidence determine whether the page’s progress is genuinely useful.
How Is Speed Index Calculated?
The exact implementation depends on the testing tool, image-comparison technique and capture pipeline. Conceptually, the initial frame begins near zero completeness and the reference final frame represents completion. Intermediate frames are compared with that final state. A page that reaches 60 percent visual completeness early earns a better score than one that remains blank and catches up later, even if both finish at the same moment. Animations, carousels, video and continuously changing regions can complicate the reference frame. Tools may mask or handle those areas differently. Preserve the filmstrip, visual-progress chart and audit version when reporting results.
- Record the viewport throughout page load.
- Select a visually complete reference state.
- Compare each frame with that state.
- Estimate visual completeness over time.
- Integrate the remaining incompleteness.
- Report the resulting time-like score.
- The exact page, asset, entity or relationship covered by this section
- The live implementation rather than an editor-only preview
- The primary specification or first-party record defining the expected behavior
- The validation result, accountable owner and review date
| Concept | Meaning | Diagnostic use |
|---|---|---|
| Frame | Captured viewport state | Observe progression |
| Final state | Reference appearance | Defines completion |
| Completeness | Similarity to final frame | Scores each moment |
| Progress curve | Completeness over time | Shows stalls |
| Incomplete area | Integrated delay | Produces score |
| Dynamic region | Continuously changing pixels | Can distort result |
Speed Index calculation summarizes an entire visual sequence, so the sequence should always accompany the reported score.
Speed Index vs FCP, LCP and TBT
These metrics can move independently. A page may show a small heading quickly for good FCP while most of the viewport stays blank, producing weaker Speed Index. A hero can produce good LCP while several visible cards continue appearing. High TBT may delay visual updates, but some long tasks occur after the view is complete. Speed Index does not measure interaction or layout stability. Use the set to describe response, first content, visual completion, main content, blocking and stability rather than collapsing them into one performance label.
- FCP: first content appears
- Speed Index: viewport fills over time
- LCP: largest candidate renders
- TBT: long-task blocking accumulates
- CLS: unexpected movement occurs
- INP: real interactions respond
- Identify the exact page, asset, entity or relationship described in this section.
- Inspect the live implementation and retain the observed evidence.
- Compare the observation with the intended meaning and its primary specification.
- Correct any mismatch, then retest the live result.
- Record the accountable owner and review date.
| Metric | Primary question | Limitation |
|---|---|---|
| FCP | When does content begin? | Not visual completion |
| Speed Index | How quickly does view fill? | Lab and visual-method dependent |
| LCP | When is main visible candidate ready? | One candidate |
| TBT | How much load blocking exists? | No actual interaction required |
| CLS | Does visible content move? | Not load speed |
| INP | Do interactions respond? | Requires field input |
Speed Index adds the shape of visual progress to a metric set, but it should never replace content, stability or responsiveness evidence.
What Causes a Slow Speed Index?
Anything that keeps a large visible region different from its final state increases the score. A slow document response delays all progress. One blocking stylesheet can hold back most text and layout. A font policy may keep headings invisible. Images referenced through late CSS or JavaScript begin after the browser could have discovered them. A client application may show skeletons until data and bundles finish. Large overlays or consent components can dominate the visual comparison. Animations and rotating carousels create unstable reference frames. Diagnose which regions remain incomplete and trace their resource or execution dependencies.
- Slow response or redirect path
- Blocking CSS and font dependencies
- Primary media discovered late
- JavaScript application shell
- Large skeletons waiting for API data
- Main-thread tasks delaying paint
- Animated or changing viewport regions
- Identify the exact page, asset, entity or relationship described in this section.
- Inspect the live implementation and retain the observed evidence.
- Compare the observation with the intended meaning and its primary specification.
- Correct any mismatch, then retest the live result.
- Record the accountable owner and review date.
| Cause | Visual symptom | Evidence |
|---|---|---|
| High TTFB | Long blank start | Navigation timing |
| Blocking CSS | Unstyled or blank view | Waterfall |
| Font delay | Invisible text region | Font timeline |
| Late images | Empty card or hero boxes | Initiator chain |
| Client rendering | Skeleton remains | DOM and API trace |
| Long task | Visual update stalls | Main-thread trace |
A slow Speed Index should be reduced by fixing the resource or task that keeps the largest useful viewport region incomplete.
How Do Images, Fonts and CSS Affect Speed Index?
Prioritize the actual initial view. Load the hero or primary product image early, but keep secondary below-fold media under lazy loading. Use responsive image sources so mobile visitors do not transfer desktop-sized files. Deliver route-critical CSS through a short rendering path while avoiding duplicate frameworks. Provide readable fallback typography and load only required font weights. Reserve media dimensions so faster visual progress does not create layout shifts. A placeholder helps perceived progress only when it represents stable useful structure rather than delaying real content indefinitely.
- Identify visible assets in each responsive viewport.
- Expose primary media in initial HTML.
- Serve correctly sized image candidates.
- Deliver only route-critical styles early.
- Use stable readable fallback fonts.
- Reserve final media and component geometry.
- Defer off-screen and optional visuals.
- The exact page, asset, entity or relationship covered by this section
- The live implementation rather than an editor-only preview
- The primary specification or first-party record defining the expected behavior
- The validation result, accountable owner and review date
| Resource | Helpful behavior | Regression check |
|---|---|---|
| Hero image | Early responsive discovery | Quality and bandwidth |
| Card images | Prioritize visible row | Scrolling behavior |
| Critical CSS | Prompt correct layout | Design parity |
| Web font | Readable stable fallback | Text reflow |
| Placeholder | Matches final geometry | Useful content timing |
| Below-fold media | Deferred request | Discovery and accessibility |
Visual-resource optimization should fill the initial viewport sooner while preserving image quality, typography, layout stability and content meaning.
How Do You Improve Speed Index?
Start with the filmstrip rather than a generic checklist. Identify the largest incomplete region during the longest visual stall. If the page remains blank, fix TTFB and blocking delivery. If skeletons dominate, shorten API and client-rendering chains or deliver stable content on the server. If images lag, repair discovery, priority and responsive sizing. If progress pauses while scripts run, reduce long tasks. Avoid inserting meaningless early paint solely to improve the curve. Test the same route content, viewport and tool profile before and after each change.
- Find the largest visual stall in the filmstrip.
- Trace the incomplete region to its dependency.
- Reduce response and redirect delay.
- Deliver useful HTML and critical styles early.
- Prioritize visible images and text.
- Reduce early main-thread blocking.
- Protect layout and interaction quality.
- Repeat under the same lab contract.
- The exact page, asset, entity or relationship covered by this section
- The live implementation rather than an editor-only preview
- The primary specification or first-party record defining the expected behavior
- The validation result, accountable owner and review date
| Finding | Candidate fix | Verification |
|---|---|---|
| Blank start | TTFB and CSS path | FCP and filmstrip |
| Skeleton stall | Server content or faster data | Truthful loading state |
| Late hero | Early discovery and sizing | LCP and bandwidth |
| Invisible text | Font fallback policy | CLS and readability |
| Script stall | Reduce long tasks | TBT and actions |
| Changing region | Stabilize or mask test area | Real UX |
The strongest Speed Index improvement replaces incomplete frames with useful stable content rather than merely changing the visual-comparison algorithm’s inputs.
How Do You Audit Speed Index?
Select representative route families and realistic content. Keep viewport, device, CPU, network, cache and tool version stable. Run several times and review median and variance. Mark FCP, LCP, visual-completion milestones and long tasks. Identify animated regions that may distort comparison. Segment the screen into major content areas and note when each reaches its final state. Trace slow regions through waterfall initiators, CSS, fonts, APIs and execution. Apply one fix class at a time, regression-test layout and controls, and retain before-and-after filmstrips. Field metrics remain necessary because Speed Index itself is a laboratory visual metric.
- Define a stable test profile.
- Select representative route content.
- Capture repeated videos and progress curves.
- Identify the largest incomplete region.
- Trace its network and execution path.
- Account for animations and rotating content.
- Verify content, layout and controls.
- Compare the same profile after release.
- The exact page, asset, entity or relationship covered by this section
- The live implementation rather than an editor-only preview
- The primary specification or first-party record defining the expected behavior
- The validation result, accountable owner and review date
| Check | Evidence | Pass condition |
|---|---|---|
| Lab contract | Saved profile | Repeatable conditions |
| Visual curve | Frame comparison | Stalls identified |
| Content regions | Filmstrip annotation | Useful progress mapped |
| Resources | Waterfall and initiators | Early visible assets |
| Execution | Main-thread trace | No avoidable paint stalls |
| Dynamic areas | Animation review | Valid reference frame |
| Regression | Route suite | Stable correct UI |
| Comparison | Same tool and version | Meaningful trend |
A complete Speed Index audit explains the visual loading curve through concrete resources and tasks, then proves a stable improvement under identical conditions.