Nov 16, 2026
Your server component is fetching in a waterfall
You moved the fetch to the server and the page is still slow. Three awaits in a row run as a queue — start the independent ones together.
Moving the fetch to the server was the right call. The page no longer waits for JavaScript to load, then fires a request, then waits again — the data is there before the HTML ships. But a server component can still make the user wait for no reason. It just waits in a different place.
Look at a dashboard page that needs three things: today's stats, recent orders, and low-stock alerts. Written the obvious way, it looks like this:
export default async function DashboardPage() {
const stats = await getStats();
const orders = await getRecentOrders();
const alerts = await getLowStockAlerts();
return <Dashboard stats={stats} orders={orders} alerts={alerts} />;
}
Nothing here is wrong in isolation. Each line is a perfectly reasonable await. But they run one after another. The orders query does not start until the stats query finishes, and the alerts query does not start until the orders query finishes. Say each one takes 200ms — the page takes 600ms before it sends anything. None of the three depends on the others. The waiting is purely structural: the code asked for the results in a queue, so the server ran them in a queue.
This is a waterfall, and it is the same bug the client side had, moved upstairs. On the client it was a useEffect chain; on the server it is three awaits in a row. The fix is also the same shape: start everything that is independent at the same time, and wait for the results together.
export default async function DashboardPage() {
const [stats, orders, alerts] = await Promise.all([
getStats(),
getRecentOrders(),
getLowStockAlerts(),
]);
return <Dashboard stats={stats} orders={orders} alerts={alerts} />;
}
The promises are created before any of them is awaited, so all three start at once. The total time becomes the slowest of the three, not the sum. That is the whole trick — Promise.all does not make anything faster; it stops making fast things wait for each other.
There is a second waterfall hiding one level down, and it is harder to spot. A parent component awaits its own data, then renders a child, and the child awaits its own data. The child's request cannot start until the parent's finishes, because the child does not exist yet. On a dashboard with a few layers of nesting, three or four round trips can stack up before the page is ready — and no single component looks slow, because each one is only doing one await.
Two patterns fix that. The first is to stop waiting for everything before showing anything. Promise.all still holds the whole page until the slowest request lands. If each section has its own <Suspense> boundary, the page itself stops being async — every section fetches its own data and streams in the moment it is ready:
export default function DashboardPage() {
return (
<DashboardGrid>
<Suspense fallback={<WidgetSkeleton />}>
<SalesChart />
</Suspense>
<Suspense fallback={<WidgetSkeleton />}>
<StockTable />
</Suspense>
<Suspense fallback={<WidgetSkeleton />}>
<AlertsFeed />
</Suspense>
</DashboardGrid>
);
}
Each widget is an async Server Component that fetches its own data. The fast ones render while the slow one is still loading, and the user sees the page filling in instead of a blank screen. This is the pattern the Next.js docs recommend: let each component own its data, and let Suspense orchestrate the loading.
The second pattern is for the case where a child only renders sometimes — a section behind a tab, or a detail panel that appears after a check. Its fetch cannot start until the parent decides to render it, which is another waterfall. The preload pattern starts the request early without awaiting it, so by the time the child runs, the data is already in flight or already there:
import { cache } from "react";
export const preload = (id: string) => {
void getOrders(id);
};
export const getOrders = cache(async (id: string) => {
// fetch the orders for this shop
});
cache is what makes this safe: the child's later call to getOrders reuses the request the preload already started instead of firing a second one. The preload function is not an API, just a convention — any name works — but the cache wrapper is the part that matters.
And the honest limits, because parallelising everything is its own bug. Some sequences are real. If the second request needs the user id from the first, it has to wait — that is a dependency, not a waterfall. The fix there is to parallelise around it: await the one real dependency, then start everything that depends on it together.
const user = await getUser(id);
const [orders, recommendations] = await Promise.all([
getOrders(user.id),
getRecommendations(user.id),
]);
Promise.all also rejects the moment any one promise rejects, so if one widget failing should not take the page down, use Promise.allSettled and handle each result on its own. And do not turn a waterfall into a stampede: starting ten independent queries at once is fine if the database can take it, but parallel is not free — it is ten concurrent connections instead of one. Measure before and after. The waterfall shows up in the simplest place: log how long each fetch takes, add them up, and compare that sum to the time the page actually took. If the page took the sum, the requests ran in a queue. If it took the slowest one, they ran together.
The rule I use now: an await is a claim that the next line needs this result. If it does not, the promise starts on the line above. Every sequential await in a page gets asked one question — does this actually depend on the one before it? If the answer is no, it does not get to wait.