Your AI-Built Site Looks Blank to AI Search. The 15-Minute Check

“I can see the page perfectly in my browser. Why does it look empty to search tools?”

That question comes up often with vibe-coded websites, no-code launches, and apps built with React, Next.js, Vue, or a Google AI Studio style workflow.

The page looks complete to you because your browser runs the JavaScript. Some crawlers may not do that.

If your headline, body copy, links, and schema are added only after JavaScript runs, the raw HTML can look almost empty to crawlers. That creates three problems at once:

1. SEO discoverability: Search engines may need extra time or resources to render your page.
2. AEO visibility: Answer engines may have little text to extract, understand, or cite.
3. Website security: Public JavaScript bundles and source maps may expose code, keys, endpoints, and internal logic.

Run this check before you spend another hour changing keywords.

The 15-minute raw HTML check

You do not need developer tools, a paid SEO platform, or a technical background.

Step 1: Open the raw page source

1. Open the page in Chrome or another browser.
2. Press Ctrl+U on Windows or Command+Option+U on Mac.
3. You can also right-click the page and select View Page Source.
4. Press Ctrl+F or Command+F.
5. Search for the exact page headline.

For example, if your visible page headline is:

The Fastest Way to Book a Local Photographer

Search for that exact sentence in the source.

Step 2: Interpret the result

What you find in View Page Source	What it means
The headline, paragraphs, links, and headings appear	Your core content is present in the initial HTML
Only a root <div>, script files, and loading text appear	The page may depend entirely on JavaScript
The title exists but the body copy does not	Search metadata exists, but the page content may be thin
Schema appears only after the page loads	Google may process it, but other crawlers may miss it
The headline is missing completely	The page is weak for crawlers that do not render JavaScript

A browser view is not the same as the first HTML response.

Google explains that Googlebot can crawl, render, and index JavaScript pages. It also recommends server-side or pre-rendering because not every bot can run JavaScript. That distinction matters for AI search.

OpenAI separately identifies OAI-SearchBot for ChatGPT search and GPTBot for training-related crawling. Perplexity uses its own crawler as well. Their rules and capabilities can change, but you should not assume that every crawler will execute your application code like a modern browser.

Why AI-built sites become invisible

Many fast website builders produce a client-side application.

The server sends something similar to this:

<html>
  <head>
    <title>My Business</title>
  </head>
  <body>
    <div id="root"></div>
    <script src="/assets/app.js"></script>
  </body>
</html>

Your browser downloads app.js, calls an API, and inserts the headline and content into the page.

A crawler that reads the initial response may see only the empty container.

Rendering approach	What the browser sees	What a limited crawler may see
Client-side rendering	Full page after JavaScript runs	Empty shell or minimal text
Server-side rendering	Full HTML arrives from the server	Full page content
Static generation	Prebuilt HTML file	Full page content
Hybrid rendering	Static content plus interactive components	Core content, even if scripts fail

❌ Risky approach: Put the headline, service description, FAQs, and internal links inside JavaScript components only.

✅ Better approach: Send the important content in static HTML, then use JavaScript for calculators, filters, menus, and other interactive features.

This is the core difference between a page that looks finished and a page that is crawlable.

SEO, AEO, and security are connected

Do not treat this as only an SEO issue.

SEO discoverability

Search engines need to find your URLs, understand your page topic, process your title, and index your content.

Client-side rendering can delay or complicate each step. Google may eventually render the page, but rendering is a separate stage from crawling. A failure, blocked script, slow API call, or oversized bundle can affect what gets indexed.

AEO and AI search visibility

Answer engine optimization depends on clear, extractable information.

ChatGPT SEO ranking, Perplexity SEO optimization, and broader AI search optimization all require your site to explain:

• What the page is about
• Who it helps
• What question it answers
• Which facts support the answer
• Where related pages can be found

If the initial HTML contains only scripts, an answer engine may have no useful answer to extract.

❌ Weak AEO structure: A visual card appears after JavaScript runs, but the raw HTML contains no meaningful heading or explanation.

✅ Strong AEO structure: The HTML includes a clear H1, a direct answer, supporting H2 sections, descriptive links, and relevant schema markup.

Website security

Fast AI-built sites also create a security blind spot.

Your public JavaScript bundle is visible to anyone. That is normal. The problem starts when the bundle exposes more than it should.

Check for:

• Hardcoded API keys
• Passwords or tokens
• Database connection strings
• Private endpoint names
• Internal file paths
• Debug comments
• Admin routes
• Unused test credentials
• Outdated JavaScript libraries

Also check for public source map files.

The .map file check

A source map connects a compressed JavaScript bundle to the original source files. Developers use source maps for debugging, but a publicly accessible production map can reveal your original code.

Step 3: Look for source maps

1. Open View Page Source.
2. Search for .js.
3. Copy the URL of a JavaScript file.
4. Add .map to the end if the filename does not already include it.
5. Open that address in your browser.

You may see a file such as:

/assets/index.abc123.js.map

If it opens and displays original source code, review it carefully.

A source map is not automatically a vulnerability. However, it can make weaknesses easier to understand. It may reveal internal logic, comments, source paths, hidden routes, and accidentally committed secrets.

❌ Do not: Publish source maps containing credentials or private implementation details.

✅ Do: Remove production source maps or restrict access. Keep secrets on the server, never inside frontend code.

If you find an exposed key, rotate it immediately. Removing the file does not invalidate a key that someone may already have copied.

The five-step repair playbook

Follow this order.

1. Put core content in static HTML

Add these directly to the server-rendered page:

• One clear H1
• The main introduction
• Service or product descriptions
• Important FAQs
• Internal links
• Primary calls to action
• Text alternatives for important images

Keep animations and interactive features, but do not make them responsible for delivering the only copy.

2. Enable pre-rendering or static generation

Open the settings for the tool you used and look for terms such as:

• Static generation
• Pre-rendering
• Server-side rendering
• SSR
• SSG
• Export static site
• Build-time rendering
• Hybrid rendering

For public marketing pages, choose pre-rendered or statically generated output when available.

If your platform cannot do this, move important pages to a system that can return complete HTML.

3. Server-render the metadata

Keep these in the initial HTML:

• Title tag
• Meta description
• Canonical URL
• Robots meta tag
• Open Graph tags
• Hreflang tags when needed

Use a Meta Tag Generator with live Google preview to prepare clean titles and descriptions.

4. Put schema in the initial HTML

Add JSON-LD for the page type, such as:

• Organization
• Article
• FAQPage
• Product
• Service
• BreadcrumbList

Do not rely on a client-side script to inject your only structured data. Use the Schema Markup Generator, then place the output in the server-rendered HTML.

5. Recheck the source and the source maps

Open View Page Source again.

Search for:

• Your page headline
• A paragraph from the page
• The H1
• An internal link
• Your schema type
• Your title and meta description

Then check the JavaScript files for public .map files and exposed secrets.

Use the right bot controls

Do not block the crawlers you want to reach.

Review your robots.txt file and decide whether you want to allow crawlers such as OAI-SearchBot, GPTBot, and PerplexityBot. Search visibility and training-related crawling can have different controls, so do not treat every bot as one setting.

The Robots.txt Generator helps you create and review rules. The llms.txt Generator can also help organize guidance and important pages for AI crawlers.

Remember this distinction:

❌ Robots rules cannot repair empty HTML.

✅ Robots rules control access to content that already exists.

First make the page readable. Then decide which crawlers should access it.

Run a final launch check

Use this quick checklist:

• The main headline appears in View Page Source
• Core paragraphs appear without JavaScript
• H1 and H2 headings are present
• Title and meta description are server-rendered
• Canonical and robots tags are present
• Schema markup appears in the initial HTML
• Important links use normal <a href> elements
• No API keys or passwords appear in bundles
• Production .map files are removed or restricted
• robots.txt does not block important pages
• The page works when JavaScript is disabled

For Search Console analysis, use the Search Console Regex Library. It includes more than 30 copy-paste patterns for question queries, long-tail searches, brand and non-brand terms, local searches, and AI-style queries.

Check everything without a login

Smart Analytics offers a free SEO and AEO analysis that checks the initial HTML, title tags, headings, schema, robots.txt, sitemap, links, content depth, performance signals, and answer structure.

It also includes a separate free Vulnerability Check for exposed files, leaked credentials, missing security headers, outdated libraries, and other common issues.

Everything is completely free. There is no login, no email requirement, and no paywall. You get the full report every time.

Specific vulnerability findings remain private in the downloadable PDF. The report also includes a custom AI Fix Prompt that non-developers can copy into an assistant to get plain-language, prioritized repair steps.

The fix is simple

Your page does not need to be built without JavaScript.

It needs a reliable HTML foundation.

Serve the important words, headings, metadata, links, and schema before the browser begins running your application. Keep JavaScript for the parts that need interaction. Remove exposed secrets and review public source maps.

That gives you a stronger foundation for traditional search, answer engine optimization, ChatGPT SEO ranking, Perplexity SEO optimization, and basic website security.

Run the raw HTML check today. It takes less than 15 minutes and can reveal a serious visibility problem before you spend more time promoting a page that crawlers can barely read.