Contents
- Why JavaScript applications can have an SEO problem
- Rendering strategies compared
- Architecture: separating public pages from the app
- Technical SEO checklist for web apps
- Core Web Vitals: performance as a ranking and revenue factor
- Checking what search engines actually see
- Conclusion
- Frequently Asked Questions
SEO for web apps rarely fails because of content – it usually fails because of technology. A single-page application that builds its content in the browser with JavaScript initially hands search engines an almost empty page. Google can execute JavaScript, but not every crawler does, and every delay costs visibility. This article shows which rendering strategy suits which pages and which technical foundations make your web app discoverable on Google and in AI search.
Why JavaScript applications can have an SEO problem
With pure client-side rendering (CSR), the server sends a minimal HTML shell and a JavaScript bundle; text, links and metadata are only created in the browser. For search engines this means:
- An extra rendering step: Google processes JavaScript pages in a separate rendering step. This generally works, but can delay indexing and updates, and fails if scripts are blocked or throw errors.
- Other crawlers: many other bots, including social network preview generators and numerous AI service crawlers, do not execute JavaScript or do so only partially. They may see nothing but the empty shell.
- Performance: large bundles delay rendering, which can affect Core Web Vitals and thus user experience and rankings.
The good news: modern frameworks largely solve these problems – provided the right rendering strategy is chosen from the start.
Rendering strategies compared
| Strategy | How it works | SEO suitability | Typical use |
|---|---|---|---|
| Client-side rendering (CSR) | Content is built in the browser | Weak for public content | Areas behind login, dashboards |
| Server-side rendering (SSR) | Server delivers finished HTML per request | Very good | Dynamic, frequently updated pages |
| Static site generation (SSG) | HTML is generated at build time | Very good, very fast | Marketing pages, blog, documentation |
| Incremental / hybrid generation | Static pages are regenerated on demand | Very good | Large catalogues, product pages |
| Prerendering for bots | Separate HTML served only to crawlers | Workaround | Transition for existing CSR apps |
Frameworks such as Next.js, Nuxt, SvelteKit or Angular with server-side rendering support SSR and SSG and let you choose the strategy per route. Our overview of web app frameworks in 2026 compares the options. Google itself describes serving separate HTML to bots (dynamic rendering) as a workaround and recommends server-side rendering, static rendering or hydration instead.
Architecture: separating public pages from the app
Not every page of a web app needs to rank on Google. Content behind a login is invisible to search engines anyway and needs no SEO work. A proven split:
- Public area: home page, feature and pricing pages, use cases, blog, help articles and, where relevant, public content such as profiles, listings or product pages – rendered statically or server-side.
- App area: everything after login, happily built as a classic single-page application, excluded via
noindexor robots.txt where publicly reachable paths exist.
This separation saves effort and lets each area use the right technology. What matters is that public content you want people to find is genuinely accessible without logging in.
Technical SEO checklist for web apps
- A URL for every piece of content: no hash routes (
/#/product), but real paths via the History API. - Real links: navigation via
<a href>elements, not click handlers on arbitrary elements – otherwise crawlers cannot follow links. - Title and meta description per route: server-side in the HTML, not set afterwards by script.
- Correct status codes: non-existent content returns a real 404 status instead of an error message with status 200 (soft 404).
- Canonical tags: for filter, sort and tracking parameters, to avoid duplicate content.
- XML sitemap: generated automatically, listing all indexable URLs.
- Do not block resources: allow JavaScript and CSS files in robots.txt.
- Structured data: schema.org markup for products, articles, FAQs or organisation in the delivered HTML.
- Multilingual content: separate URLs per language with hreflang annotations, rather than switching language by cookie only.
Core Web Vitals: performance as a ranking and revenue factor
Google assesses user experience partly through the Core Web Vitals: Largest Contentful Paint (LCP) for how fast the main content loads, Interaction to Next Paint (INP) for responsiveness and Cumulative Layout Shift (CLS) for visual stability. Web apps have typical weak spots here:
- JavaScript bundles that are too large – code splitting and removing unused libraries help.
- Heavy hydration that briefly blocks the page after loading.
- Late-loading images, banners or fonts that shift the layout.
- Data requests that only start in the browser instead of being prepared on the server.
Concrete measures are covered in our article on performance optimisation. Measure with field data from Search Console, not only with lab tests on a fast developer machine.
Checking what search engines actually see
Do not rely on how the page looks in your own browser. These checks show what crawlers actually receive:
- Page source rather than developer tools: viewing the page source shows the delivered HTML. If headings and text are missing there, the page depends on JavaScript.
- URL inspection in Google Search Console: shows the rendered HTML, blocked resources and indexing status.
- Test without JavaScript: load the page with JavaScript disabled – this is how many AI crawlers see your content.
- Lighthouse and PageSpeed Insights: for performance, accessibility and basic SEO checks.
How your content shows up in the answers of AI assistants is covered in our article on generative engine optimization.
Agentic coding workshop for your team? From €799 net – request a quote by e-mailConclusion
Web apps can rank very well if public content is rendered server-side or statically, every page has its own URL and metadata, and performance is right. The actual app area behind the login can still be built as a single-page application. If you are planning a new web app or want to make an existing one more visible, we will prepare a fixed-price offer after a free analysis.
Frequently Asked Questions
Can Google index JavaScript pages?
Yes, Google renders JavaScript in a separate step. This can delay indexing, however, and fails in the event of errors or blocked resources, so server-rendered HTML is the safer choice for important pages.
Do I need server-side rendering for my entire web app?
No. SSR or static generation makes sense for public, search-relevant pages; areas behind the login can remain client-side rendered.
Is a single-page application bad for SEO?
A purely client-side SPA is unfavourable for public content. Modern frameworks, however, combine the benefits of an SPA with server-rendered HTML, so the architecture need not be an SEO obstacle.
Can AI crawlers see my JavaScript content?
Many AI crawlers do not execute JavaScript, or do so only partially. Content that is already present in the delivered HTML is therefore captured more reliably.