After 7 Next.js 16 Caching Bugs, I Stopped Guessing and Built a System

There's a specific feeling you get after your third production caching incident.

It's not panic. It's worse than panic. It's that quiet realisation that you fixed the last bug correctly, and you still have no idea where the next one is hiding.

After the 7 silent caching bugs post, a pattern kept coming up in the comments. Everyone understood what was breaking, but not what the correct setup should look like. This is that answer.

Not theory. The actual system I use now, after getting burned enough times to understand why each piece exists.

The first problem: tag strings written from memory in different files

Most silent cache bugs in Next.js 16 start here. Not because anyone is being careless. Because there is nothing stopping two people from writing two different strings that should be the same.

Developer A writes the data function on Monday:

async function getProducts() {
  'use cache'
  cacheTag('product-list')
  return db.query('SELECT * FROM products')
}

Developer B writes the mutation two weeks later in a different file:

export async function createProduct(data: ProductData) {
  await db.query('INSERT INTO products ...', [...])
  revalidateTag('products', 'max')
}

product-list and products. Two different strings. Zero errors from TypeScript, zero warnings from Next.js. The product list never refreshes after a new product is created and nobody knows why until someone reads both files at the same time.

This is Bug 3 from the previous post. I kept hitting variations of it across different parts of the codebase even after I knew about it, because knowing about a problem and having something that prevents it are not the same thing.

The fix is one file that owns all your tag strings:

// lib/tags.ts
export const tags = {
  product: (id: string | number) => `product-${id}`,
  user: (id: string | number) => `user-${id}`,
  productList: 'products',
  userList: 'users',
  navigation: 'navigation',
} as const

Now both files import from tags. A typo is a TypeScript compile error. The string mismatch bug cannot happen. Everyone on the team gets autocomplete instead of muscle memory.

// data function
cacheTag(tags.productList)

// mutation — same import, same string, guaranteed
revalidateTag(tags.productList, 'max')

This is the single change that removed the most bugs from my codebase, by far. Set it up before you write a single cached function on a new project.

The second problem: three different places to invalidate cache, three different correct APIs

This is where I see the most confusion, including in my own early code. The API you reach for depends entirely on where you're calling from and what the user needs to see. Get it wrong and you either throw at runtime or silently give someone stale data.

Here is how I think about it now:

Inside a Server Action where the user who just made a change needs to see it immediately:

'use server'
import { updateTag, revalidateTag } from 'next/cache'

export async function updateProductPrice(id: string, newPrice: number) {
  await db.query('UPDATE products SET price = $1 WHERE id = $2', [newPrice, id])

  updateTag(tags.product(id))               // acting user sees fresh data right away
  revalidateTag(tags.product(id), 'max')    // everyone else gets SWR update
  revalidateTag(tags.productList, 'max')    // product list refreshes too
}

The order matters here. updateTag runs first. This is what prevents the admin from clicking save, navigating back to the product page, and seeing the old price. That looks like the save failed. It causes people to click save again. updateTag fixes it.

updateTag is Server Actions only. Calling it anywhere else throws at runtime.

Inside a Route Handler (webhooks, external services):

// app/api/webhooks/stripe/route.ts
import { revalidateTag } from 'next/cache'

export async function POST(req: Request) {
  const event = await parseStripeWebhook(req)
  if (event.type === 'price.updated') {
    revalidateTag(tags.productList, { expire: 0 })
  }
  return new Response('ok', { status: 200 })
}

updateTag is not available in Route Handlers. { expire: 0 } is the equivalent for immediate expiry here. This is what you want for webhooks where a third-party system just told you something changed.

Background updates where a brief stale window is fine:

revalidateTag(tags.productList, 'max')

Stale-while-revalidate. Users get a fast cached response while fresh data loads behind the scenes. For most content this is exactly right. An admin publishes a new post, readers might see the old list for a moment, that is usually acceptable.

Here is the whole thing as a decision table:

Write this down somewhere your team can see it. Saves a lot of "why is the user seeing old data after saving" conversations.

The third problem: the PPR split is invisible by default

With cacheComponents: true, Next.js uses Partial Prerendering. Your page has a static shell that renders instantly from cache and dynamic holes that stream in after. The performance win is real. The problem is that what ends up in the shell versus what ends up as a dynamic hole is not obvious until something behaves wrong.

One component with cacheLife('seconds') gets quietly excluded from the static shell. A cookies() call inside a cached scope throws at build time with "Uncached data was accessed outside of Suspense" and gives you no component name, no file path, nothing useful. A dynamic component added without a Suspense boundary pushes part of the page out of the shell.

The way I stopped guessing about this is to document intent at the component level:

// components/UserCart.tsx
export const boundary = {
  name: 'UserCart',
  isDynamic: true,
  reason: 'Reads user session cookie — different per user',
}

Then in the page that uses it, I reference that intent explicitly:

export default async function ProductPage({
  params,
}: {
  params: Promise<{ id: string }>
}) {
  const { id } = await params

  // UserCart is dynamic — must be in Suspense or it breaks the static shell
  return (
    <div>
      <ProductDetails id={id} />       {/* cached, part of static shell */}
      <RelatedProducts id={id} />      {/* cached, part of static shell */}
      <Suspense fallback={<CartSkeleton />}>
        <UserCart productId={id} />    {/* dynamic, streams in after */}
      </Suspense>
    </div>
  )
}

The cached components look like this:

async function ProductDetails({ id }: { id: string }) {
  'use cache'
  cacheLife('hours')
  cacheTag(tags.product(id))

  const product = await db.query(
    'SELECT * FROM products WHERE id = $1', [id]
  )
  return <article>...</article>
}

The dynamic component has no 'use cache' at all:

async function UserCart({ productId }: { productId: string }) {
  const cookieStore = await cookies()
  const userId = cookieStore.get('user-id')?.value
  const cartItem = await db.query(
    'SELECT * FROM cart WHERE user_id = $1 AND product_id = $2',
    [userId, productId]
  )
  return cartItem ? <InCartButton /> : <AddToCartButton />
}

Static shell hits the user instantly. Cart streams in after. The split is intentional and documented, not whatever survived the algorithm.

One more thing on this: never call cookies(), headers(), or draftMode() inside a 'use cache' scope. Read them outside, pass the values as props. Those values become part of the cache key automatically — different users produce separate cache entries without you doing anything extra.

The fourth problem: cold starts hurt the first visitor after every deploy

This one is separate from the bugs but connects to the same goal. Your caching is set up correctly. You deploy. The first visitor hits the page and every cached function runs from scratch sequentially because the cache is empty.

PPR is fast once the cache is warm. That first request after a deploy is not.

The fix is React's cache() for request-level deduplication. Fire all your data fetches in parallel at the top of the page before any component needs them:

import { cache } from 'react'
import { getProductById, getRelatedProducts } from '@/lib/data'

const prefetch = {
  product: cache(getProductById),
  related: cache(getRelatedProducts),
}

export default async function ProductPage({
  params,
}: {
  params: Promise<{ id: string }>
}) {
  const { id } = await params

  void prefetch.product(id)
  void prefetch.related(id)

  return (
    <div>
      <ProductDetails id={id} />
      <RelatedProducts id={id} />
      <Suspense fallback={<CartSkeleton />}>
        <UserCart productId={id} />
      </Suspense>
    </div>
  )
}

Both fetches fire immediately in parallel. Child components that call the same functions get deduplicated results from React's cache(). If a prefetch fails it fails silently. It is an optimisation, not a requirement. The actual fetching in child components still works.

The distinction worth knowing: React's cache() deduplicates within a single request. 'use cache' persists across requests. You need both, they solve different problems.

What the full system looks like

One tags file. Everyone imports from it. A typo is a compile error, not a production incident.

A clear decision for invalidation context: Server Action with a user waiting for their change uses updateTag first, then revalidateTag. Route Handler uses revalidateTag with { expire: 0 }. Background broadcast uses revalidateTag with 'max'.

Dynamic components documented and always wrapped in Suspense. The static shell is explicit, not accidental.

Prefetch fired in parallel at the top of heavy pages so the first visitor after a deploy is not the one paying the cold start cost.

None of this is complicated once you have it written down. The hard part was figuring out that I needed all of it, which took enough production bugs to see the pattern.

The earlier posts in this series cover how I got here. Building the debugger when development was a black box. The seven bugs that compile and break silently. The upgrade breaks that the build never warns you about.

If you want the full migration reference, I wrote that at shubhra.dev/tutorials/nextjs-16-cache-components.

I kept hitting these edge cases often enough that I eventually pulled the whole system into a single utility. The Cache Pro Kit is the production version of everything in this post. Type-safe tag registry, safeRevalidate that blocks the single-arg call at compile time, serverActionInvalidate that enforces the correct order, routeHandlerInvalidate so updateTag in a Route Handler is impossible. One file, drop into lib/.

What does your caching setup look like right now? Have you hit any of these in your own projects?