Thursday, November 19, 2026← Weras Labs main siteTürkçe
WerasBlog

What's happening in AI, software, technology and science; plain and sourced.

Subscribe
Software

Technical SEO for Web Applications: What to Do During Development

JavaScript-heavy web apps carry different search engine risks than classic websites. Here are the technical SEO steps to take while the app is still being built.

Technical SEO for Web Applications: What to Do During Development
Image: Stephen Phillips - Hostreviews.co.uk · Unsplash · Unsplash License

Technical SEO for web applications covers the measures you take during development so search engines can find, crawl and understand your app's public pages without trouble, and see that it delivers a fast experience. For JavaScript-heavy apps, the single most critical point is serving content as ready-made HTML from the server instead of building it in the browser after the fact. In this article we walk through what to watch for on the technical SEO side while building a web app, in language product owners can follow.

Why web applications need special attention

On a classic website, every page arrives from the server as finished HTML. Some modern web apps, on the other hand, first send the browser an empty page and a large JavaScript bundle; the content appears only after that code runs. Search engines can execute JavaScript, but doing so takes extra resources, can be delayed and is prone to errors. Social media link previewers often don't run JavaScript at all.

That's why technical SEO decisions aren't settings you bolt on later; they're decisions about the app's architecture. Once development is underway, they can be hard and expensive to change.

Separate app pages from marketing pages

Not every page in a web app needs to show up in search. There are usually two kinds of pages:

  • Public pages: The home page, feature and pricing pages, blog posts, help articles, public profile or product pages. These need to be searchable.
  • Pages behind a login: The user dashboard, settings, reports. These don't need to appear in search results, and usually you don't want them to.

The first job is deciding which pages should be searchable. Technical SEO effort focuses on those pages; the inside of the app can be kept closed to search engines.

Technical SEO for web applications: the essentials

1. Server-side rendering or static generation

The content of searchable pages should arrive as HTML that is either rendered on the server (server-side rendering) or generated at build time (static generation). Frameworks such as Next.js, Nuxt and Astro support both approaches. That way the search engine sees the page's title, text and links on the very first request.

  • Navigation between pages should use real link tags. Buttons that only work through a click handler may not be followed by search engines.
  • Every page should have its own readable, permanent URL, such as "/blog/mvp-scope".
  • Filter and sort parameters shouldn't generate an endless number of URLs; where needed, those variations should point to a canonical URL.

3. Per-page metadata

Every searchable page should have a unique title tag and meta description. In single-page apps, it's a common mistake for every page to carry the same title. In addition:

  • Canonical tag: If the same content lives at more than one URL, it states which one is the original.
  • Open Graph tags: These control the title, description and image shown when a link is shared on social media.
  • Language tags: If you have content in multiple languages, hreflang tags connect the language versions to one another.

4. Sitemap and robots.txt

Your searchable pages should be listed in an XML sitemap that updates automatically as content is added. The robots.txt file tells search engines which sections not to crawl. Make sure preview and staging environments are closed to search engines, and that production isn't accidentally blocked.

5. Correct status codes

A page that doesn't exist should return a 404, and a page that has moved permanently should return a 301 redirect. In single-page apps, a common problem is pages that display a "page not found" message while technically returning a 200 (success) status code.

6. Structured data

Structured data in Schema.org format tells search engines what type of content a page holds: an article, a product, frequently asked questions, organization details and so on. Used correctly, it can enable rich results in search, but it has to be consistent with the visible content on the page.

Search engines discover pages largely by following links. Connecting your public pages to each other with meaningful links makes it easier both to find new pages and to understand which pages matter most. In practice, that means:

  • Link from feature pages to related help articles and blog posts.
  • Add natural links from blog posts to relevant product or service pages.
  • Don't leave "orphan" pages that no other page links to.
  • Use heading hierarchy correctly on each page: one main heading, with logically ordered subheadings beneath it.

These steps are technically simple, but they require the content management system and page templates to be designed to allow them.

Performance and Core Web Vitals

When Google evaluates page experience, it uses a set of metrics called Core Web Vitals:

  • LCP (Largest Contentful Paint): How long it takes for the largest content element on the page to appear.
  • INP (Interaction to Next Paint): How quickly the page responds to user interactions.
  • CLS (Cumulative Layout Shift): Whether elements shift around unexpectedly while the page loads.

Common ways to improve these metrics in web apps:

  • Cutting unnecessary JavaScript and splitting code by page,
  • Serving images at the right size and in modern formats, with their dimensions declared up front,
  • Loading fonts efficiently,
  • Keeping third-party scripts (analytics, chat widgets, ad pixels) to a minimum and loading them late,
  • Caching pages that don't change often.

Questions you can ask your development team

  • Are the searchable pages rendered on the server or in the browser?
  • Does every page have its own title and description tags?
  • Is the sitemap generated automatically?
  • Do missing pages return the correct status code?
  • Are preview environments closed to search engines?
  • How will Core Web Vitals be tracked?
  • If you're migrating from an old site, is there a redirect plan for the old URLs?

Monitoring after launch

Technical SEO isn't a one-and-done task. You need to monitor indexing issues, crawl errors and page experience metrics regularly with tools like Google Search Console. As new features are added, and especially when new page types are created, check that the steps above are applied to those pages too.

Considerations for multilingual apps

If your app serves content in more than one language, each language version should have its own URL (for example, language-prefixed paths). Switching the language at the same URL based only on browser settings or a cookie makes it hard for search engines to see the different language versions. Each language page should point to its counterparts with hreflang tags, and the translations should genuinely speak to users in that language.

Conclusion

Technical SEO for web applications is largely an architectural decision. Serving searchable pages as ready-made HTML from the server, giving every page its own URL and metadata, returning correct status codes and delivering good performance are the cornerstones. Planning them at the start of development prevents expensive fixes after launch. At Weras Labs, we treat technical SEO requirements as part of the scope of web projects from day one; see our services page for how we work.

#technical seo#web application#core web vitals#search engines

From Weras Labs

We can help you with this

We turn what you just read into working software for your business. You talk to the person writing the code; price and timeline are clear from day one.

Frequently asked questions

Can single-page applications (SPAs) rank on Google?

They can, but if content is built only in the browser with JavaScript, crawling can be delayed and error-prone. Rendering searchable pages on the server or generating them statically is a more reliable approach.

Should the app's user dashboard be open to search engines?

Usually not. Pages behind a login don't need to be searchable; technical SEO effort should focus on public pages such as the home page, feature pages, the blog and help content.

What are Core Web Vitals?

They're the metrics Google uses to measure page experience: LCP for loading speed, INP for responsiveness to interaction and CLS for visual stability.

Can technical SEO be added after launch?

Some steps, like meta tags or a sitemap, can be added later. But architectural decisions such as server-side rendering are expensive to change after the fact, so it's best to plan them from the start.

About the author

Habip Dayan

Habip Dayan

Founder of Weras Labs

Habip Dayan is the founder of Weras Labs, a company that builds software products for professionals and teams. He has been building software since 2018 and writes about AI, cloud architecture and product design.

Comments

Be respectful; no ads or personal data. Comments that break the rules are removed.