Free tools Windows power users keep installed
One-click scans. No signup required.
iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more
Most EmDash “stale page” and duplicate-tag incidents are variance problems, not mysterious SEO failures. First determine which layer served the response: EmDash’s object cache, a full HTML cache at the edge, a browser cache, or media storage. Then compare an anonymous request with the cookie-bearing editor request, make shared caching anonymous-only, assign every SEO field to one emitter, and purge each affected layer in order.
This guide gives a practical runbook for EmDash sites behind a CDN or mixed plugin stack. It also explains why editor toolbars disappear, why canonical and Open Graph tags duplicate, and how to prove whether a plugin is involved.
Start with the symptom and the response variant
Before changing a setting, write down the exact URL, query string, login state, cookies, and the action that produced the symptom. A page that is correct for a logged-in administrator but stale for a visitor is not receiving the same response variant. Treat that difference as evidence of cache variance.
Recommended Free Tools
Capture the headers that identify a cached response
Inspect the response source and headers for both an anonymous request and a cookie-bearing editor request. Record:
#1 Best Overall
- URL and query string: include every parameter, because a preview flag or personalization parameter can change the rendered HTML.
- Cookies and authentication: note whether the request carries a session, editor, preview, or other cookie.
- Cache-Control: look for
privateorno-store, which indicate that a response must not be shared or stored. - ETag and Age: an unchanged ETag or a growing Age value can show that an older representation is being reused.
- Via and CDN status: these headers can reveal that a proxy or edge cache, rather than EmDash, supplied the body.
- Rendered source: inspect the final HTML delivered to the browser, not only the editor preview or an admin-side representation.
If anonymous and editor requests differ in cookies, cache status, or HTML, fix the cache boundary before debugging SEO parsing. A parser cannot recover metadata that never reached the response.
Know which cache is responsible
EmDash installations can have several independent caches. Each has a different scope, set of variance inputs, and purge operation. Clearing one does not clear the others.
EmDash object cache
The objectCache setting caches content and configuration query results used while EmDash builds a page. It is disabled when omitted. Documented adapters include Cloudflare KV through kvCache and an in-memory Node/development cache. This layer can make newly changed content or configuration look old even when the final HTML is not stored at the edge.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Object caching is a data-query cache: its entries represent objects or query results, not necessarily complete HTTP responses. A successful object-cache purge forces EmDash to read current content and configuration on the next render, but it does not remove an already cached HTML document in a CDN or browser.
Full-response and CDN cache
An outer middleware or CDN can cache the complete HTML response. This is separate from objectCache. The edge layer must vary on every request property that changes rendering, including cookies, authentication, query strings, relevant headers, locale, and any preview or edit state. If it does not, one visitor’s representation can be served to another.
Full-response caching is where editor leakage most often occurs: a shared cache stores an anonymous page and later returns it when an editor expects a toolbar or preview. Conversely, a response generated for an editor can leak private information if the cache accepts it.
Browser cache
The browser may retain HTML, JavaScript, CSS, or images after the server and CDN are correct. A hard reload or a browser-cache clear is useful only after server-side layers have been purged. Browser caching cannot explain a fresh private response viewed in a different browser, so use an independent client to separate local state from origin state.
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Media delivery
Images and downloads may come from R2 or another S3-compatible store, often through a public URL. Media has its own object keys, host name, protocol, path, and query-string policy. A stale image object does not prove that the page HTML is stale. Verify the media URL and its storage or CDN cache independently.
| Layer | What it stores | Important variance inputs | Typical purge | Can it store private output? |
|---|---|---|---|---|
EmDash objectCache |
Content and configuration query results | Query arguments and the data/configuration inputs used by the query | EmDash object-cache clear operation | It should not be treated as a public HTML cache; follow the adapter’s isolation rules |
| Outer HTML/CDN cache | Complete HTTP responses | Method, URL, query string, cookies, authentication, relevant headers, locale, preview/edit state | CDN or Workers Cache purge | No; bypass or refuse responses marked private or no-store |
| Browser cache | Local HTML and static assets | Browser cache policy, URL, validation headers | Hard reload or browser data clear | Only within that user’s browser, but it can still show an old page |
| Media storage/CDN | Images and other media objects | Public host, protocol, path, object key, query-string policy | Media-object or media-CDN purge | Public media should not contain user-specific output |
Make shared HTML caching safe for anonymous visitors
The safe default is to cache only successful, anonymous GET HTML responses. Requests with cookies, authentication, preview state, or any other user-specific input must bypass the shared cache. Responses carrying private or no-store must never be stored.
Use an outer middleware gate
Place the full-response cache outside EmDash and apply these decisions before reading or writing an edge entry:
- Reject non-GET methods. Do not cache POST, PUT, PATCH, DELETE, or other mutation requests.
- Reject cookie-bearing requests. A cookie can identify a logged-in editor, a preview session, or another personalized state. Bypass unless you can prove that a particular cookie is irrelevant and encode that decision deliberately.
- Include every rendering input in the key. The key must account for every URL component and request property that changes output. If a header, locale, query parameter, or authorization state can alter HTML, it must either be in the key or trigger a bypass.
- Fetch and validate the origin response. Store only a successful HTML response. Do not cache redirects, error pages, non-HTML assets, or responses whose headers prohibit storage.
- Honor privacy directives. Skip storage when
Cache-Controlcontainsprivateorno-store. Preserve those directives when returning the response. - Separate lookup and write rules. The same bypass logic must run on cache reads and writes; otherwise a bypassed request can still receive an entry created under incompatible conditions.
On Node, Redis or another equivalent store can implement the same design. The product does not make the cache safe by itself; safety comes from consistent key and bypass rules.
Do not hide variance in templates
Session-dependent branches in your own templates fragment the cache or, worse, render one user’s branch into a shared entry. Remove editor-only or account-specific markup from public HTML, or make the entire response private. Public HTML should be identical for all anonymous visitors that share the same cache key.
Prevent editor and preview leakage
When a shared CDN sits in front of EmDash, set the toolbar configuration to toolbar: 'client'. EmDash’s configuration reference recommends client mode for public HTML served through shared caches such as Cloudflare Cache Everything, Workers Cache, Fastly, or Varnish.
Server toolbar injection can be mixed with an anonymous cached response: the edge may return HTML generated without the current editor state, so the toolbar appears to vanish or an old one appears unexpectedly. Client mode keeps the shareable public HTML identical and obtains a fresh edit response when the editor requests it.
Keep edit and preview responses private
EmDash renders preview and edit responses with Cache-Control: private, no-store. Your outer middleware must respect those headers and must not write those responses into a shared cache. A request carrying an editor or preview cookie should bypass the cache before lookup, not merely after the origin has rendered the page.
Test the three paths separately:
- Anonymous public URL: should be eligible for a shared HTML entry when the response is successful and cacheable.
- Authenticated editor URL: should bypass shared storage and include the current editing state.
- Preview or edit response: should return private, no-store directives and should not increase the public cache’s Age.
Audit media URLs separately from HTML
If an image remains old while text and metadata are current, inspect the storage URL rather than purging the page repeatedly. For R2 and S3-compatible adapters, verify the configured publicUrl and confirm that the public hostname, protocol, path, and query-string policy are stable.
Common media mistakes
- A hostname change leaves old URLs in rendered content while the new bucket receives updates.
- HTTP and HTTPS variants create separate cache objects.
- A path prefix differs between the storage key and the public URL.
- Query strings are ignored by one layer but included by another, so an image transformation or version parameter is not consistently applied.
- The media CDN is purged while the browser still holds the old object.
Compare the exact media URL in the delivered HTML with the URL you expect. If the HTML contains the wrong URL, return to EmDash content or configuration caching; if the URL is correct but the bytes are old, purge the media layer.
Give SEO metadata one owner
Duplicate titles, canonical links, robots directives, Open Graph tags, Twitter cards, or JSON-LD usually mean that two emitters believe they own the same field. Treat metadata as a contract: every field has one authoritative producer, and the final HTML is the source of truth.
What EmDash can emit
EmDash’s sandboxable page:metadata surface supports descriptions, robots directives, Twitter cards, Open Graph and property tags, canonical and alternate links, and JSON-LD. Use it when the requirement is structured SEO metadata. Raw scripts, styles, or arbitrary HTML require a native plugin instead of the sandboxed metadata hook.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Clear out junk files and repair common Windows errorsFree Scan →Assign ownership field by field
| Field | Choose one owner | What to verify in final source |
|---|---|---|
| Title | EmDash metadata or the other SEO system, not both | One effective <title> element with the intended text |
| Description | One metadata emitter | One description value and no stale duplicate |
| Canonical | One canonical-link producer | One rel='canonical' URL matching the intended public URL |
| Alternate links | One internationalization or SEO owner | Expected language or format alternates without conflicting URLs |
| Robots | One policy owner | One effective robots directive; confirm preview and private pages are handled separately |
| Open Graph and Twitter | One social-metadata owner | One value for each required property or name |
| JSON-LD | One structured-data owner per schema item | No duplicate graph nodes that describe the same page unless intentionally distinct |
If another SEO plugin emits the same fields, disable its overlapping output or narrow its scope. Do not assume that two identical tags are harmless: crawlers and social parsers may choose different copies, especially when values disagree.
Inspect the response, not the admin preview
View source or capture the origin/edge response after caches are cleared. Check the exact HTML delivered to an anonymous client, then repeat for an editor. An admin preview can show values that a cached public response does not contain, while a browser extension can hide ordering and duplicate details.
Confirm how each plugin executes
EmDash separates native plugins from sandbox-compatible plugins. Native packages belong in plugins. Sandbox-compatible packages belong in sandboxed and require a usable sandboxRunner.
Symptoms of a mode mismatch
- A sandboxed plugin is listed in configuration but never changes output because no runner is configured; the documentation says it is skipped in that condition.
- A native plugin is placed in the sandboxed list even though it needs unrestricted access to raw scripts, styles, or arbitrary HTML.
- A metadata hook runs, but a raw injection requirement is silently unmet because the plugin format is too restrictive.
For diagnosis only, temporarily set sandbox: false and compare the result. If behavior changes, the execution boundary or runner configuration is implicated. Restore sandboxing immediately after the comparison; disabling isolation is not a production fix.
Purge caches in a deliberate order
After changing metadata, templates, plugin registration, or cache rules, purge from the innermost generated data outward:
- Clear EmDash object cache. This removes cached content and configuration query results so the next render uses current data.
- Purge full-page and CDN entries. Remove the HTML representation from the edge or Workers Cache, including variants created under old keys.
- Clear the browser only if necessary. Use a hard reload or clear site data after server-side layers are fresh.
The official troubleshooting plugin exposes object-cache and Workers Cache clear actions when the required EmDash cache capability is available. If you use a different CDN, perform its equivalent purge and confirm the purge result rather than assuming that an origin refresh also removed edge entries.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Run a controlled plugin-conflict test
For WordPress-originated integrations or a mixed plugin stack, use a reversible isolation procedure. Back up first, because deactivation can change runtime behavior.
- Record the affected URL, response headers, metadata, and the exact symptom.
- Clear the caching plugin’s cache so an old response does not survive the test.
- Deactivate all nonessential plugins while leaving the minimum required platform and EmDash components active.
- Refresh the page in an independent browser session and compare the final HTML and headers.
- Reactivate one plugin at a time, clearing the relevant cache after each change, until the symptom returns.
- When the conflict is identified, assign metadata ownership or adjust execution mode instead of leaving unrelated plugins disabled.
If the issue persists with every nonessential plugin disabled, treat it as a theme, server, CDN, or platform problem rather than a plugin conflict. This conclusion follows the isolation guidance published by Elegant Themes support.
Use a symptom-to-cause decision tree
The page is stale only for anonymous visitors
Compare the anonymous response’s Age, CDN status, ETag, and body with the origin response. A hit at the edge or a browser cache is more likely than an EmDash object-cache problem. Purge the HTML layer, then validate the cache key and bypass rules so the old entry cannot be recreated.
The editor sees a public page without the toolbar
Check for an editor cookie and determine whether the request was served from a shared cache. Set toolbar: 'client', ensure edit responses are private and no-store, and bypass cookie-bearing requests before cache lookup.
Text is current but an image is old
Compare the media URL in delivered HTML with the storage configuration. Check publicUrl, host, protocol, path, and query handling, then purge the media object or its CDN rather than repeatedly purging HTML.
Canonical or social tags appear twice
View the final source and list every emitter. Decide which system owns each field, disable or narrow the overlapping output, purge object and HTML caches, and inspect a fresh anonymous response.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Scan for outdated or missing drivers - takes under a minute3Repair Windows errors before they cause bigger problemsA plugin appears configured but has no effect
Check whether it is under plugins or sandboxed and whether sandboxRunner is available. Use the temporary sandbox: false comparison only to confirm the execution boundary, then restore isolation.
Verification checklist before closing the incident
- An anonymous GET receives the intended HTML and has no editor-only markup.
- A cookie-bearing editor request does not read from or write to the shared HTML cache.
- Preview and edit responses retain
Cache-Control: private, no-store. - The cache key and bypass logic account for every request input that changes rendering.
- Media URLs resolve through a stable public host, protocol, path, and query policy.
- Each title, canonical, robots, social, and JSON-LD field has one owner.
- The final response source contains the expected metadata exactly once where uniqueness is required.
- Plugin placement matches its execution mode, and sandboxing is enabled again after diagnosis.
What a durable fix looks like
A durable EmDash deployment makes the cache boundary explicit: anonymous successful HTML may be shared, while cookie-bearing, authenticated, preview, edit, private, and no-store responses bypass storage. It keeps object, HTML, browser, and media caches operationally separate, so each symptom leads to the correct purge. It also treats SEO output as a single-owner contract and verifies the delivered source after every change.
When those rules are in place, a stale page, missing toolbar, old image, or duplicate tag becomes a traceable variance or ownership issue instead of trial-and-error cache clearing.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
