Blog / Technical SEO /
What to check when rendered content differs from editorial content
The page looks perfect in the CMS. The live page shows an old title, a missing paragraph and last month’s price. You edit the copy again. Still wrong. You edit it a third time.
Stop editing. The gap between the editorial record and the rendered page can come from templates, caching, conditional logic, scripts or the publishing workflow, and more copy changes won’t fix any of them.
The CMS isn’t always what a visitor sees. A field may map to the wrong component, a cache may serve yesterday’s version, or a script may swap text after load. Follow the content through each stage instead.
Identify the exact difference
Capture the editorial record, the preview and the published page. Note the URL, field, expected value, actual value, browser and time. If the page changes by device, location, login state or query parameter, record that too. “The content is wrong” is hard to debug; a specific comparison isn’t.
Confirm that the correct record is being edited. Similar products, translations or campaign pages may have nearly identical names. Check the CMS ID, slug and variant where relevant. Make sure the edit was published rather than saved as a draft or left in a scheduled state.
Look at the page in a clean session and a second browser. That separates a rendering issue from a local cache or extension. Don’t keep editing the copy while you test, and change one thing at a time. I always open the live page in a private window first, before blaming the template.
Trace the content mapping
Review how the CMS field maps into the template. A component may read a fallback field, hide content behind a condition, or use a referenced item nobody updated. Check whether a reusable block or global component overrides the page-level value.
If the content comes from a CMS collection, verify the field type, reference and locale. A rich-text field may render differently from a plain-text field. Empty optional fields can shift the layout or cause a fallback string to appear. Test with a representative entry that contains the same combinations of populated and blank fields.
Inspect the rendered DOM and network requests when appropriate. Compare the HTML response with the content after JavaScript runs. If the text appears only after a script executes, check whether the script is loading, whether an error stops it, and whether search engines can render the result. Avoid assuming that a missing visual element is an SEO problem before understanding the user impact.
Check cache and publishing layers
A cache can serve an older version after an editor publishes a change. Check the CMS preview, page cache, CDN and browser cache in sequence. Purge only the relevant cache, and only after confirming the published record is correct. Clearing every cache hides which layer caused the delay, and I’d rather know.
Confirm the deployment or publishing process actually finished. Some systems separate content publish from production deployment, so a preview can show the latest data while the public site runs an older build. On client sites, I check the release status before I republish anything.
Make the correction traceable
When the cause is clear, update the right layer: source content, field mapping, component condition, build or cache rule. Document the specific fix and verify the same URL afterward. If many pages are affected, test one page per template before applying a bulk correction.
Compare all versions of the page
A mismatch may only appear after a user action or under a particular condition. Compare the preview, the published HTML and the fully rendered page. If the site has several languages or variants, inspect the right locale and product selection. If a visitor must sign in, test signed-in and anonymous states with authorised test accounts.
Check the source data for stale references. A page may pull a related record, global component or reusable block rather than its own field. If a shared block is wrong, changing individual pages may create inconsistent workarounds. Identify the source of truth and correct the shared value when appropriate.
Check version history and deployment records. Was the editor’s change saved, published and included in the live build? If the latest version shows in preview but not production, record the exact release state and ask the platform owner to inspect the pipeline.
For a recurring mismatch, create a minimal test entry that reproduces the field combination. Use it in staging to compare the template before and after a fix. Avoid putting sensitive or customer-specific details into test content. Once verified, remove the test record and document what field mapping caused the discrepancy.
Check whether the problem is repeatable
Try the same page and field combination several times, allowing for cache delay or an asynchronous request. If the mismatch is intermittent, note how often it occurs and what conditions are present. A video can show timing, but avoid capturing personal information or internal admin screens that do not need to be shared.
Ask another authorised editor to preview the same record. If they see a different result, compare their role, preview URL and browser state. Permissions can cause different fields or drafts to appear. Make sure the page has not been opened through an old preview link that refers to a prior revision.
For a collection with many entries, compare a few records that use the same template. If only one record is affected, inspect its field values and references. If every entry in one page type is wrong, investigate the shared component or data mapping. This distinction helps a developer choose between a record correction and a systemic fix.
Related reading
- Using crawl statistics to check Googlebot activity
- Technical SEO: redirect loops after app removal
- Technical SEO: log files for practical SEO questions
Rendering correctly doesn’t prove the content is right. When was the CMS value on your key pages last compared with what the live page actually shows?