All articles
DevOps & CloudNovember 9, 2026 6 min read

Vercel ISR vs On-Demand Revalidation: When Each One Actually Breaks

ISR and on-demand revalidation look interchangeable until traffic shifts or a CMS webhook misfires. Here's what we've learned shipping both patterns across e-commerce and content sites.

We've shipped Next.js on Vercel for enough clients now — commerce catalogs, publisher sites, marketing pages — that the choice between time-based ISR and on-demand revalidation stops being a style preference and starts being an incident waiting to happen. Both work. Both have failure modes that only show up when someone else is on-call.

This is the mental model we hand to new engineers before they touch a revalidate export or a webhook route.

What the two patterns actually do

Incremental Static Regeneration (ISR) regenerates a page in the background after a time window expires. You set export const revalidate = 60 and Vercel serves the cached HTML to anyone who hits that route, kicking off a regeneration if the cache is older than 60 seconds. The next visitor gets the fresh copy. Simple, predictable, and the failure mode is "users see slightly stale data".

On-demand revalidation flips the trigger. Instead of a timer, something external — usually a CMS webhook or an admin action — calls revalidatePath() or revalidateTag(). The cache is invalidated immediately, and the next request regenerates. In theory you get fresh content the instant it changes. In practice, you've just made your edge cache dependent on the reliability of your CMS's webhook delivery.

The decision isn't technical, it's organisational

Before we talk about code, the question we ask the client: who notices first when a page is wrong — the editor or the user?

If the editor notices ("I just published this and it's not live!"), on-demand revalidation is worth the complexity. If the user notices ("this price is three days old"), time-based ISR with a sensible window is usually enough and far less to maintain.

Where ISR quietly breaks

The pitch is clean. The failure modes are not.

Low-traffic pages never regenerate

ISR regenerates on a request. If nobody visits /blog/old-article-from-2022 for three weeks, that page sits in cache for three weeks. When a backlink suddenly drives traffic, the first visitor gets stale HTML and triggers the regeneration. Fine for a blog post. Not fine for a product page you quietly removed from inventory.

We hit this with a client's long-tail SEO pages. A promotional price expired, the revalidate window was 3600 seconds, but the pages got maybe one visit a day. Every one of those visits saw the expired promo. The fix was moving to on-demand revalidation triggered by the pricing service, not shortening the window.

Cache stampedes on viral spikes

When a page goes viral and the cache expires, Vercel's ISR implementation handles concurrent regenerations reasonably well — but your origin doesn't always. If your generateStaticParams or data fetching pulls from a database that's already under load from the traffic spike, you can amplify the problem. We've seen a database CPU graph that looked fine at steady state double during cache refresh windows because every edge region kicked off its own regeneration against the same backend.

The mitigation is boring: cache your data layer separately. Don't rely on ISR being your only cache.

The build-time vs runtime confusion

generateStaticParams controls what's built at deploy time. revalidate controls what happens after. We've reviewed codebases where someone set revalidate = 60 on a page with 50,000 dynamic params and then wondered why their Vercel function invocation count spiked. Every unique URL that gets traffic eventually regenerates. Every regeneration is a function invocation. Math it out before you ship.

Where on-demand revalidation quietly breaks

The pitch is "instant freshness". Reality is "instant freshness, if everything in the chain works".

Webhook delivery is not a guarantee

Most headless CMSs — Contentful, Sanity, Strapi, Payload — fire webhooks on publish. Most of them retry on failure. None of them guarantee delivery. We've had cases where a Contentful webhook silently 500'd because our Vercel function cold-started past the CMS's timeout, the retry happened 30 seconds later when the editor had already moved on, and nobody noticed the page was stale for a week.

Add observability on the receiving end:

// app/api/revalidate/route.ts
import { revalidateTag } from 'next/cache';
import { NextRequest, NextResponse } from 'next/server';

export async function POST(req: NextRequest) {
  const secret = req.headers.get('x-webhook-secret');
  if (secret !== process.env.REVALIDATE_SECRET) {
    return NextResponse.json({ ok: false }, { status: 401 });
  }

  const { tag, source, entryId } = await req.json();

  try {
    revalidateTag(tag);
    // Log to your observability stack, not just console
    await logRevalidation({ tag, source, entryId, status: 'ok' });
    return NextResponse.json({ revalidated: true, tag });
  } catch (err) {
    await logRevalidation({ tag, source, entryId, status: 'error', err });
    // Return 500 so the CMS retries
    return NextResponse.json({ ok: false }, { status: 500 });
  }
}

The logRevalidation call matters more than the revalidateTag call. If you can't answer "did this webhook fire and succeed?" within 30 seconds of an editor asking, you don't have on-demand revalidation — you have hope.

Webhook storms during bulk operations

An editor runs a bulk update across 400 entries. Your CMS fires 400 webhooks in roughly the same second. Your revalidate endpoint is a Vercel function with a concurrency limit. Half the webhooks time out, the CMS retries them 30 seconds later, and now you've got a thundering herd against your data layer.

The pattern we use now: webhook handlers write to a queue (SQS, Upstash QStash, or just a lightweight debounce in Redis) and a separate worker calls revalidateTag in batches. You lose a few seconds of freshness and gain a system that doesn't collapse during a content migration.

Tag collisions are silent

revalidateTag('product') will invalidate every fetch tagged 'product' across your entire app. If two teams both used that tag, congratulations — the marketing team's CMS publish just invalidated the entire product catalog cache. Namespace your tags from day one:

// Good
fetch(url, { next: { tags: [`product:${id}`, 'product:all'] } });

// Trouble waiting to happen
fetch(url, { next: { tags: ['product'] } });

The hybrid that usually wins

For most of our production work, neither pattern alone is the answer. The setup we reach for:

  • Time-based ISR as the floor. Set revalidate to something generous — an hour, a day — so pages never go truly stale even if the webhook pipeline breaks.
  • On-demand revalidation as the ceiling. Wire up revalidateTag for the content types where freshness matters, with namespaced tags and logged webhook handlers.
  • A manual "nuke this page" tool for editors. A tiny admin endpoint that calls revalidatePath on a URL the editor types in. This is the escape hatch for when the webhook misfires, and it will.

This hybrid costs a bit more in function invocations than pure ISR and a bit more in engineering time than pure on-demand. In return, you get a system where the worst-case staleness is bounded by your revalidate window, not by "whenever someone notices".

What the numbers tend to look like

In our experience across a handful of mid-sized Next.js sites:

  • Pure time-based ISR at 60-second windows: cheapest to run, but editorial complaints every few weeks about "why isn't my change live".
  • Pure on-demand revalidation: editorial happiness is high until the first webhook outage, at which point trust collapses and takes months to rebuild.
  • Hybrid with a 1-hour floor and on-demand tags: slightly higher function invocation cost (we've seen 10–25% increases depending on content velocity), near-zero editorial complaints, and incidents are bounded.

These ranges depend heavily on traffic shape and content update frequency. Measure your own.

Where we'd start

If you're setting this up fresh on a new project:

  1. Default every page to time-based ISR with a conservative window — an hour is a reasonable starting point.
  2. Identify the three or four content types where freshness actually matters to the business. Add tagged fetches and on-demand revalidation for those only.
  3. Build the webhook handler with logging and a secret from day one. Treat it like a payment webhook, not a side project.
  4. Add a manual revalidation tool in your admin UI before you need it.

If you want a second pair of eyes on an existing Next.js setup, our DevOps and cloud team does architecture reviews that usually pay for themselves in reduced function invocations alone. And if you're deeper in the Vercel rabbit hole, the rest of our blog has more war stories from the edge.

#Vercel#Next.js#Caching#DevOps

Want a team like ours?

72Technologies builds production software for the kind of teams who actually read this blog.

Start a project