data-fetching-patterns

Implement efficient data-fetching strategies for SSR, SSG, ISR, and client-side rendering.

35|5|Updated Feb 5, 2026
One-click install
npx skills add https://github.com/Kinfe123/fm-skills --skill data-fetching-patterns-kinfe123
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: data-fetching-patterns
Source: https://github.com/Kinfe123/fm-skills/tree/main/data-fetching-patterns
Command: npx skills add https://github.com/Kinfe123/fm-skills --skill data-fetching-patterns-kinfe123

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you identify and implement efficient data-fetching strategies to optimize loading performance in web applications.

Core Features & Use Cases

  • Patterns covered: fetch on render, fetch then render, render as you fetch, and server-side data fetching; guidance for SSR/SSG/ISR and client-side rendering; caching, streaming, and suspense usage.
  • Use cases include optimizing initial load, handling parallel vs dependent requests, and progressively rendering content with skeletons and placeholders.

Quick Start

Configure a page to fetch data on render, add a Suspense boundary around components, and replace a loading state with a skeleton while data loads.

Frequently Asked Questions about data-fetching-patterns

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I optimize data fetching for SSR and SSG to improve initial load performance?

Optimizing data fetching for SSR and SSG involves selecting efficient loading patterns like fetch-then-render or render-as-you-fetch to minimize waterfalls and improve initial load performance. This Skill guides implementing these strategies across server and edge compute environments.

What is the difference between fetch on render, fetch then render, and render as you fetch?

Fetch on render triggers requests during component rendering, fetch then render waits for data before displaying, and render as you fetch initiates loading earlier to overlap network and render phases. These patterns dictate how data fetching impacts perceived application speed.

How do I use Suspense boundaries with skeletons for progressive rendering?

Using Suspense boundaries with skeletons involves wrapping components to progressively render content, replacing standard loading states with skeleton placeholders while data streams. This technique significantly improves perceived performance by showing immediate UI structure.

What's the best way to handle parallel versus dependent data requests in web applications?

The best way to handle parallel versus dependent data requests is to identify independent queries for concurrent fetching and await dependent requests sequentially. This Skill provides guidance on combining these request structures to optimize loading performance.

Does this data fetching guidance apply to ISR and client-side rendering scenarios?

Yes, this data fetching guidance applies to Incremental Static Regeneration (ISR) and client-side rendering scenarios. It covers strategies across various rendering models, including server-side, edge compute, and progressive rendering techniques.

When should I use caching and streaming for data fetching over standard client-side loading?

You should use caching and streaming over standard client-side loading when optimizing initial load and handling complex data fetching workflows. These techniques reduce redundant requests and progressively send HTML chunks to the browser for faster perceived load times.