Pre-Launch SEO Warmup for Nuxt & Vue Sites

Preparing the public site early lets you catch access and metadata mistakes before launch. It does not create a guaranteed period of trust or ranking advantage.

The New Domain Reality

Ahrefs' 2025 ranking study sampled URLs first seen or created in 2023. Its two samples used different selection rules and produced different results. The older 5.7% figure belongs to its 2017 study. None of these samples tested a pre-launch warmup.

Use your own launch requirements to decide when to publish. Check indexing through Search Console rather than assuming domain age guarantees visibility.

The Warmup Timeline

This schedule spreads the technical preparation across several weeks. Adjust it to when your public content is ready.

Every week your domain sits empty is a week Google learns nothing about you. Start deploying content the moment DNS is live.

Deploy Early with a Landing Page

Most teams hide behind basic auth or a "coming soon" splash. Search engines see no content and move on. Deploy a real page instead: SSR, proper meta tags, structured data.

The Nuxt example assumes Nuxt Schema.org is installed. For Vue, configure Unhead and its Schema.org integration in your app first. The form endpoint and image paths are placeholders.

<script setup lang="ts">
useSeoMeta({
  title: 'Acme Dev Tools',
  description: 'Ship faster with automated testing and deployment pipelines for modern web apps. Launching Spring 2026.',
  ogTitle: 'Acme Dev Tools',
  ogDescription: 'Automated testing and deployment for modern web apps.',
  ogImage: 'https://acme.dev/og-preview.png',
})

useSchemaOrg([
  defineOrganization({
    name: 'Acme Dev Tools',
    url: 'https://acme.dev',
    logo: 'https://acme.dev/logo.png',
    sameAs: [
      'https://twitter.com/acmedev',
      'https://github.com/acmedev',
    ],
  }),
  defineWebPage({
    name: 'Acme Dev Tools',
    description: 'Automated testing and deployment for modern web apps.',
  }),
])
</script>

<template>
  <div>
    <h1>Acme Dev Tools</h1>
    <p>Ship faster with automated testing and deployment pipelines.</p>
    <form action="/api/waitlist" method="post">
      <input type="email" name="email" placeholder="Get early access" required>
      <button type="submit">
        Join Waitlist
      </button>
    </form>
  </div>
</template>

<script setup lang="ts">
import { defineOrganization, defineWebPage, useSchemaOrg } from '@unhead/schema-org/vue'
import { useSeoMeta } from '@unhead/vue'

useSeoMeta({
  title: 'Acme Dev Tools',
  description: 'Ship faster with automated testing and deployment pipelines for modern web apps. Launching Spring 2026.',
  ogTitle: 'Acme Dev Tools',
  ogDescription: 'Automated testing and deployment for modern web apps.',
  ogImage: 'https://acme.dev/og-preview.png',
})

useSchemaOrg([
  defineOrganization({
    name: 'Acme Dev Tools',
    url: 'https://acme.dev',
    logo: 'https://acme.dev/logo.png',
    sameAs: [
      'https://twitter.com/acmedev',
      'https://github.com/acmedev',
    ],
  }),
  defineWebPage({
    name: 'Acme Dev Tools',
    description: 'Automated testing and deployment for modern web apps.',
  }),
])
</script>

<template>
  <div>
    <h1>Acme Dev Tools</h1>
    <p>Ship faster with automated testing and deployment pipelines.</p>
    <form action="/api/waitlist" method="post">
      <input type="email" name="email" placeholder="Get early access" required>
      <button type="submit">
        Join Waitlist
      </button>
    </form>
  </div>
</template>

The example includes a crawlable <h1>, Organization data, and Open Graph tags. The waitlist form gives interested visitors a next action. The example needs your own endpoint and privacy notice before use.

Don't serve a blank page behind JavaScript or return a 503 status either. A blank client-rendered page requires JavaScript support. A 503 indicates temporary unavailability.

<script setup lang="ts">
// Real content with SSR meta tags
useSeoMeta({
  title: 'Acme Dev Tools',
  description: 'Automated testing for modern web apps. Launching Spring 2026.',
})
</script>

<template>
  <div>
    <h1>Acme Dev Tools</h1>
    <p>Automated testing and deployment pipelines for modern web apps.</p>
  </div>
</template>

<template>
  <!-- No meta tags, no real content, no SSR value -->
  <div class="coming-soon">
    <img src="/logo.svg">
    <p>Coming Soon</p>
  </div>
</template>

Set Up Search Console Before Launch

Create your Google Search Console property the day you put the domain live. Don't wait until launch day.

Verification and First Steps

1. Visit search.google.com/search-console
2. Add a Domain property (covers all subdomains and protocols)
3. Verify ownership via DNS TXT record (most reliable method)
4. Submit your sitemap at Indexing > Sitemaps, even if it only contains one URL
5. Use URL Inspection to request indexing for your landing page manually

Use DNS verification. It persists through deployments, while HTML file or meta tag verification can break when you redeploy.

Why This Matters Early

Verify Search Console early so you can inspect the available data and access diagnostics. The available reports depend on what Google has observed. Finding a noindex mistake at week 3 beats discovering it on launch day.

Even with a single page, GSC reveals:

• Whether Google can access your site
• If your SSL certificate is valid from Google's perspective
• Whether your robots.txt is blocking anything unintentionally
• How quickly Google recrawls after you make changes

Seed Content Early

Patrick McKenzie (patio11) makes the case for publishing content before you have a product: if you can't show the app yet, talk about the problem domain in the language your customers already use. Each page targets different keywords and gives Google more to evaluate before day one.

Blog Setup

For Nuxt, follow the current Nuxt Content documentation to define your collection and page renderer. Installing the module alone does not create a working blog.

For Vue, choose a static or server renderer before adding Markdown content. A Markdown import does not make a client-rendered page available in the initial HTML. See prerendering.

Give each published article its own title, description, and crawlable URL. Add Article structured data when it accurately describes the page.

What to Write About

Target keywords your audience is already searching for. If you're building a testing tool:

• Common testing patterns and best practices
• Comparisons of existing tools (honest, not salesy)
• Tutorials solving real problems your audience has

Publish an article when it answers a useful question on its own. Avoid filler written only to add an indexed page.

Build Initial Authority Signals

Help visitors find the project from your existing profiles and related work. Use contextual links that serve those visitors.

Cross-Link from Existing Properties

If you have any existing web presence, link to the new domain:

• Personal blog or company blog
• GitHub organization profile and repository READMEs
• Other products or tools you maintain
• npm package pages (the homepage field in package.json)

{
  "name": "acme-testing",
  "homepage": "https://acme.dev",
  "repository": {
    "type": "git",
    "url": "https://github.com/acmedev/acme-testing"
  }
}

Social Profiles and Community Presence

Create Twitter/X, LinkedIn, and GitHub profiles linking to your domain. These profiles help visitors identify the project. Include the URLs in your defineOrganization() sameAs array so Google connects them.

Share the project on Twitter/X and in relevant communities. Share useful pages with communities where they answer a real question.

Choose relevant references rather than a target number of links.

Save Product Hunt and Hacker News for launch day when you can convert the traffic spike into signups. Choose launch channels based on your audience. No domain rating predicts the benefit of a particular link.

For a deeper look at link building strategies, see Backlinks & Authority.

Technical Foundation

Get the technical foundation right before publishing. Misconfigurations during warmup can actively hurt your launch.

Get the Config Right

Install the Nuxt modules listed below before enabling them. For the Vue example, install vite-plugin-sitemap in your existing Vite project. Sitemap generation does not render your Vue pages.

export default defineNuxtConfig({
  site: {
    url: 'https://acme.dev',
    name: 'Acme Dev Tools',
  },
  modules: [
    '@nuxtjs/sitemap',
    '@nuxtjs/robots',
    'nuxt-schema-org',
  ],
  robots: {
    // Allow all crawlers during warmup
    groups: [
      { userAgent: ['*'], allow: ['/'] },
    ],
  },
  sitemap: {
    // Automatically discovers routes
    // Configure your content collection using the current sitemap integration.
  },
})

import vue from '@vitejs/plugin-vue'
import { defineConfig } from 'vite'
import sitemap from 'vite-plugin-sitemap'

export default defineConfig({
  plugins: [
    vue(),
    sitemap({
      hostname: 'https://acme.dev',
      dynamicRoutes: [
        '/blog/why-automated-testing-matters',
        '/blog/ci-cd-for-beginners',
      ],
    }),
  ],
})

For Vue without a framework, also create a static robots.txt:

User-agent: *
Allow: /
Sitemap: https://acme.dev/sitemap.xml

Verify SSR is Working

The most common mistake: your site looks fine in the browser but serves empty HTML to crawlers. Always verify with curl:

curl -s https://acme.dev | grep -o '<title>.*</title>'
# Should output: <title>Acme Dev Tools</title>

curl -s https://acme.dev | grep -o '<meta name="description".*>'
# Should output your description meta tag

If metadata is missing, check rendering mode, head setup, and the page's metadata declarations. For Nuxt, inspect any ssr: false configuration. Check main content separately. If client rendering omits content that your readers or clients need, consider prerendering or an SSR framework.

Canonical URLs

Point your canonical URL to the intended public domain. The Nuxt example requires nuxt-seo-utils or @nuxtjs/seo, which generates canonical tags from Site Config. The Vue example requires an Unhead provider:

export default defineNuxtConfig({
  site: {
    url: 'https://acme.dev', // Always the production domain
  },
})

import { useHead } from '@unhead/vue'
import { useRoute } from 'vue-router'

const route = useRoute()

useHead({
  link: [
    { rel: 'canonical', href: () => `https://acme.dev${route.path}` },
  ],
})

Use the intended public URL as the canonical hint. Keep staging access and indexing restrictions separate.

Robots.txt

Confirm your robots.txt allows crawling. Deploying with Disallow: / left over from staging is surprisingly common:

curl https://acme.dev/robots.txt
# Should show:
# User-agent: *
# Allow: /
# Sitemap: https://acme.dev/sitemap.xml

If the matching user-agent group has Disallow: /, that rule blocks crawling for that crawler. Remove it immediately and request recrawling in Search Console.

Launch Day Execution

If you've done the warmup, your public pages may already have been discovered. Confirm their status in Search Console. Launch day adds to that footprint instead of building it from zero.

Launch Checklist

1. Remove launch restrictions from intended public pages; keep private routes protected
2. Deploy full site with all pages, features, and content
3. Submit updated sitemap in Search Console with all new URLs
4. Notify participating engines through IndexNow when relevant public URLs change
5. Post on social for an initial traffic burst (Twitter/X, LinkedIn, Reddit, Hacker News)
6. Request indexing for your top 5 to 10 pages in Search Console URL Inspection

IndexNow Configuration

Use the IndexNow guide for a complete submission example and key-file requirements. Notifications apply only to participating engines. A successful submission does not guarantee crawling or indexing.

Keep the submission endpoint authenticated if you expose it through your app. Do not publish an unrestricted route that lets strangers trigger external requests.

The Traffic Burst Matters

Launch visitors can help you check whether the site works for its audience. CrUX requires eligible Chrome observations and sufficient data; a traffic burst alone does not guarantee a report.

Check each launch result separately. A processed sitemap does not prove its URLs are indexed, and Google may still use cached robots rules after a live fix. Use Google Search timelines to choose the next observation rather than waiting a fixed number of days.

Measuring Your Warmup

How do you know the warmup is working? Track these signals in Google Search Console:

Export available Search Console data when you need a launch baseline. An export cannot recover data the source omitted or no longer retains.

What's Next

Ready to launch? Run the SEO Checklist to verify nothing slips through. It covers meta tags, crawlers, performance, and AI discovery with links to framework-specific implementation guides.

Using Nuxt? One command automates most of the technical setup in this guide:

npx nuxt module add @nuxtjs/seo

The Nuxt SEO module handles sitemaps, robots.txt, schema.org, canonical URLs, and OG images so you can focus on content and authority. Version 6 also sets up llms.txt, Markdown versions of each page, and skew protection.

Want the full learning path? The complete SEO guide for Nuxt or Vue walks through every topic from rendering to monitoring.

Already live? Use the free Meta Tag Checker and XML Sitemap Validator to catch issues in minutes.