Are PWAs really indexable by Google, or will the # ruin everything?

Why does Google emphasize the web standard for PWAs?

Google reminds us that PWAs use classic web technologies (HTML, CSS, JavaScript) rather than a closed proprietary framework. This standard foundation theoretically ensures that Googlebot can read and index content just like any other web page.

The engine makes no technical distinction between a PWA and a traditional site. What matters for indexing is the crawler's ability to retrieve the content, not the label 'Progressive Web App.' The 'immersive' user engagement mentioned by Google pertains to the experience (push notifications, offline mode, installation), not SEO.

What exactly is the issue with the # symbol?

URLs with # fragments (hash) pose a historic concern in SEO. Traditionally, anything following the # is not sent to the server during an HTTP request. The fragment remains client-side and is used for internal navigation within the page.

In single-page application (SPA) architectures, some developers use hash routing (#/about, #/products) to change views without reloading the page. Googlebot ignores everything that follows the #, so these sections will never be crawled or indexed if they are only accessible this way.

How does Google actually crawl a PWA?

The engine expects that each 'page' or important view has a unique, clean URL, with no fragment. The ideal architecture relies on the HTML5 History API (pushState), which allows manipulation of the URL without reloading while maintaining standard paths (/about, /products).

If the PWA generates content dynamically via JavaScript, Googlebot needs to execute the JS and wait for the complete rendering. Google has been doing this for years, but it is still slower and more fragile than server rendering. JavaScript errors or timeouts can block partial or total indexing.

• PWAs are indexable if they adhere to classic HTML/CSS/JS standards
• URLs with # hide content: Googlebot ignores everything following the fragment
• Routing must use the History API (pushState) to create clean URLs without hash
• JavaScript rendering must be fast and reliable: JS errors = invisible content
• No difference in treatment between PWAs and traditional sites from a crawl/indexing perspective

Does this statement align with field observations?

Yes and no. On paper, Google is right: a well-coded PWA normally gets indexed. In practice, poorly architected PWAs pose chronic problems. Product teams often prioritize mobile experience without consulting SEO experts, leading to hash routing, broken lazy-loading, or poorly injected dynamic meta tags.

Field audits show that many PWAs lose organic traffic after migrating from a traditional site. Not because Google can't index them, but because the JavaScript implementation introduces regressions: late-rendered content, internal links invisible on the first crawl, missing or duplicated canonical tags. [To be verified] systematically with a JavaScript SEO audit before any production deployment.

What nuances should be considered regarding JavaScript rendering?

Google implies that everything works 'easily' if standards are met. This is optimistic. JavaScript rendering remains a costly operation for Googlebot, which can delay indexing by several days or even weeks on low crawl budget sites.

PWA e-commerce sites sometimes experience temporary delisting of product pages during peak periods (sales, Black Friday) because the crawler can't render the entire catalog in time. Server-side rendering (SSR) or static site generation (SSG) are the only true guarantees of fast and stable indexing.

In what cases does this rule not apply?

Google does not specify anything about complex PWAs requiring mandatory authentication. If the main content requires a login, Googlebot won't be able to access it even if the URLs are clean. Some sites put the entire catalog behind a login wall 'for the PWA experience', which is pure and simple SEO suicide.

Another borderline case: PWAs that use service workers to serve different hidden content depending on the context (offline vs online, aggressive A/B testing). Google may detect unintentional cloaking if the content served to the crawler differs significantly from what is shown to the user. Let's be honest, many developers don't consider this when configuring their service worker caching strategy.

What concrete steps should be taken for an indexable PWA?

First priority: eliminate all hash routing. Migrate to History API (pushState/replaceState) so that each view has a clean URL. Test with the URL inspection tool in Search Console to ensure that Googlebot sees the correctly rendered final content.

Next, implement pre-rendering or SSR for critical pages (category pages, product sheets, SEO landing pages). Solutions like Rendertron, Prerender.io, or Next.js in hybrid mode allow serving static HTML to crawlers while maintaining the client-side PWA experience. It's extra work but the only way to ensure fast and stable indexing.

What mistakes should be absolutely avoided?

Never launch a PWA in production without a JavaScript rendering audit using the Mobile-Friendly Test and the URL inspection tool. JavaScript errors that go unnoticed in development (network timeouts, blocked CDN dependencies) can become rampant in production when Googlebot crawls with tight quotas.

Another common mistake: forgetting dynamic meta tags. Many PWAs inject title, description, and canonicals via JavaScript after the first paint. If the bot crawls before the complete injection, you end up with indexed pages without a title or duplicates. Inject these critical tags server-side or through SSR, never just client-side.

How can I verify that my PWA site is compliant?

Run a full crawl with Screaming Frog in JavaScript mode and compare it with a crawl with JS disabled. The discrepancies show exactly what Googlebot might be missing. Also, check server logs for hits from Googlebot returning a 200 status but with empty or partial content.

Use Google Search Console to monitor rendering errors in the Coverage section. Pages marked 'Explored, currently not indexed' or 'Detected, currently not indexed' often indicate JavaScript rendering issues or insufficient crawl budget to process all dynamic content.

• Migrate all # routing to History API with clean URLs
• Implement SSR or pre-rendering for strategic SEO pages
• Test each critical template with the Google URL inspection tool
• Inject title, meta description, and canonical tags server-side, never just via client-side JS
• Crawl the site with Screaming Frog JS enabled/disabled to spot discrepancies
• Monitor Search Console for rendering or delayed indexing errors