An editor changed a product name in the CMS, saved the publication, and opened the site—but the old name was still there. This does not always mean the save failed. The public page, the CMS request, and an intermediate CDN may each hold different versions of the data. First, identify which layer is serving the old value.
We’ll look at a custom demo store built with Next.js 15 and the App Router. The /catalog/red-mug product card gets public information from the CMS, and the CMS sends the server a notification after a change. The addresses, fields, and authorization method here are illustrative; the actual handler must be aligned with your CMS documentation.
Check where the old name is still present
Compare three results: the value in the CMS editor, the published response from its API, and the store page’s HTML. Note the exact new name, product ID, time of the change, and environment. The editor preview may show a draft, while the site correctly receives the latest published version.
If the API returns old data, updating Next.js will not solve the problem. Check the publication status, locale, record version, and the source’s own cache. If the API already returns the new value but the page shows the old one, move on to the application and hosting settings.
Open the page directly without signing in. Navigation within an already-open app may use state or the client cache from the current session. You need a fresh document response for comparison. If you have multiple domains, make sure the CMS notifies production, not a preview from a previous build.
Define page caching explicitly
In Next.js 15, you cannot explain every delay by saying “fetch caches everything automatically.” fetch responses are not cached by default, but how the route itself is rendered also affects the page you receive. Check the actual settings where the data is loaded. Next.js fetch documentation 15.
Our demo request deliberately uses a server cache with periodic revalidation. It should be placed in a server function used by the page and, if needed, its metadata. The exact source URL must come from trusted configuration, not from an arbitrary visitor parameter.
const response = await fetch(productApiUrl, {
cache: 'force-cache',
next: { revalidate: 3600 },
})
if (!response.ok) throw new Error('Product source failed')
const product = await response.json()Here, one hour is an illustrative freshness choice, not a recommended setting for every store’s prices or inventory. Purchase-related information may require a different policy. Agree on which data can be served from cache and for how long. Do not use mutually exclusive options together, such as no-store and a nonzero revalidation interval for the same request.
Add a webhook that verifies the sender
A webhook is an HTTP request the CMS uses to notify you of an event. Receiving such a request does not prove that the page was updated. The server first verifies the sender and the record in question, then marks the related routes for revalidation.
Below is a simplified custom app/api/cms-updated/route.ts handler. It assumes the demo CMS can send an agreed secret in the Authorization header. Use the verification method supported by your actual CMS; if it requires an HMAC signature, verify it against the raw request body before parsing the JSON.
import { revalidatePath } from 'next/cache'
export async function POST(request: Request) {
const secret = process.env.CMS_WEBHOOK_SECRET
if (!secret) return Response.json({ accepted: false }, { status: 503 })
if (request.headers.get('authorization') !== `Bearer ${secret}`) {
return Response.json({ accepted: false }, { status: 401 })
}
const payload = await request.json().catch(() => null)
const slug = payload?.slug
if (typeof slug !== 'string' || !/^[a-z0-9-]{1,80}$/.test(slug)) {
return Response.json({ accepted: false }, { status: 400 })
}
revalidatePath(`/catalog/${slug}`)
revalidatePath('/catalog')
return Response.json({ accepted: true }, { status: 202 })
}The secret is stored on the server and in the sender’s settings, not in a public NEXT_PUBLIC_ field. The example does not limit the size of the request body or the request rate; these controls must be added at the handler or infrastructure level before production. Do not let the external payload specify an arbitrary path, so that any request cannot trigger updates to any section of the site.
Separate event acceptance from new data appearing
When revalidatePath is called from a Route Handler, Next.js marks the path for revalidation on the next visit. Our handler’s 202 response means the event was accepted, not that new HTML is already ready. This distinction matters for the CMS interface and logs. How revalidatePath works.
So verification has two separate steps. First, make sure the CMS received a successful response from the correct endpoint. Then request the updated product card and look for the new name in the returned document. If the second step has not succeeded, the report must not say “page update confirmed.”
One record may appear in several places: a product card, a category, search results, and a collection. Our example updates the product card and the catalog’s home page. It does not automatically update every other place where the record is used. Document the related routes; if you use a shared data model, consider revalidating by cache tags, after checking the mechanism for your Next.js version.
Test a normal event and delivery failures
Prepare one test product card in a staging environment. Save the original name, then change it to a distinct test value. Send an event with the correct authorization and, after it is accepted, request the page again. The CMS, API, and HTML should all show the same value.
Then run negative checks. A request without the secret must not be accepted. Invalid JSON and an unsupported slug must not mark routes for revalidation. Repeating a valid event should still produce a correct result. If the event arrives before the new record is published, repeat the check after publication and clarify the CMS event order.
Check how the sender reports failed delivery and retries. If it does not retry, periodic revalidation at the configured interval may reduce how long stale data is served, but it does not prove delivery. The team needs a way to spot a stuck event, not just a general green status for the webhook configuration.
If the source data is new but the external document is still old, compare the application response with the CDN response. Add the identified cache layer to the task. Do not clear all caches one by one without recording the result: that could hide the cause until the next product change.
What to check after publishing the fix
Record acceptance against a specific item: the old value, new value, save time, event ID, handler response, and resulting HTML. Separately note which related pages were updated. If the product URL changed, cache revalidation alone is not enough: you need new links, a canonical URL, and a decision about the old URL.
Also check for data-source errors. After a webhook, the application must not treat a malformed CMS response as a successful product card. How to handle API failures. Product deletion, a price change, and a heading change are different scenarios; testing only the name does not verify all three.
Save a technical audit of the updated page after manual verification. It will show the available results on the launch date, but it will not verify the webhook signature or delivery history. General context on caching and routes is available in the Next.js 15 guide.
Observe the next normal editorial cycle without manually clearing the cache. If the page updates after a real save and a new request, the mechanism has passed a useful check. The search crawler still needs to revisit the URL: changes to the HTML and updates to information in search do not happen at the same time.