Sitemap Is Not Enough

Notes on Telling Search Engines, Not Just Hoping They Show Up

Most developers ship a sitemap and consider the SEO infrastructure done.

The sitemap is there. The robots.txt points to it. The Search Console is connected.

That is a good start.

It is not enough.

A sitemap is a document. It tells search engines what pages exist and when they were last modified. But it does not notify anyone. It just sits there, waiting to be read.

Whether Google reads it today, next week, or next month — that is entirely up to Google.

1. What Google Actually Does with Your Sitemap

Google crawls your sitemap on its own schedule.

For a high-traffic site with strong backlinks, that schedule might be frequent — sometimes daily. For a personal site or a new domain, it could be weeks between visits.

This is called crawl budget. Google allocates it based on signals like domain authority, link profile, and how often your content changes.

You cannot increase your crawl budget by asking nicely. But you can send a signal that something changed.

2. The Problem with Staying Passive

The default approach to SEO infrastructure is passive.

Publish content. Update the sitemap. Wait.

The sitemap will eventually be crawled. The content will eventually be indexed. But "eventually" on a low-authority domain can mean days or weeks.

For a personal portfolio or a growing blog, that delay is real. A new article that takes two weeks to appear in search results is two weeks of visibility lost.

The solution is not to game the algorithm. It is to communicate directly.

3. Sitemap Ping — One Request, No Ceremony

The oldest and simplest method is a sitemap ping.

You send a GET request to a specific Google or Bing endpoint, with your sitemap URL as a query parameter. That is the entire protocol.

// src/lib/seo/pingSitemap.ts

const PING_TARGETS = [
  {
    name: "Google",
    buildUrl: (sitemap: string) =>
      `https://www.google.com/ping?sitemap=${encodeURIComponent(sitemap)}`,
  },
  {
    name: "Bing",
    buildUrl: (sitemap: string) =>
      `https://www.bing.com/ping?sitemap=${encodeURIComponent(sitemap)}`,
  },
];

export async function pingSitemap(): Promise<PingResult[]> {
  const sitemapUrl = absoluteUrl("/sitemap.xml");
  // ping all engines in parallel, return results
}

The signal this sends is broad: "something in my sitemap changed, come check it."

Google or Bing will then schedule a crawl of the sitemap — not immediately, but sooner than their default interval.

Not instant. But faster than silence.

4. IndexNow — Telling Search Engines Exactly What Changed

IndexNow is a different protocol, built for a more specific signal.

Instead of "check my sitemap," it says "this exact URL was just updated."

// src/lib/seo/indexNow.ts

const INDEX_NOW_TARGETS = [
  { name: "Bing",   endpoint: "https://www.bing.com/indexnow",   enabled: true  },
  { name: "Yandex", endpoint: "https://yandex.com/indexnow",     enabled: true  },
  { name: "Google", endpoint: "https://www.google.com/indexnow", enabled: false },
];

export async function pingIndexNow(urls: string[]): Promise<IndexNowResult[]> {
  const body = JSON.stringify({ host, key, keyLocation, urlList: urls });
  // POST to all active targets in parallel
}

The protocol requires a key — a unique string that proves you own the domain. You host a small text file at /{key}.txt, and the search engine verifies it before processing your submission.

Bing and Yandex officially support IndexNow. Google is still evaluating it.

The practical difference from sitemap ping:

Sitemap ping tells Google to re-read a document that lists your pages. IndexNow tells Bing to index a specific URL, now.

One is broad. One is precise.

5. When to Use Which

They are not competing approaches. They serve different purposes.

Sitemap ping makes sense when you want search engines to re-read your entire site structure, when you publish many pages at once, or when you are targeting Google specifically since IndexNow is not officially supported yet.

IndexNow makes sense when a specific page was just updated and you want it re-indexed quickly, or when you can identify exactly which URLs changed.

In practice, both can run together.

Sitemap ping for the broad signal. IndexNow for the specific one.

6. Automating Both

Running these manually is fragile. A cron job is more reliable.

On Vercel, a cron is one entry in vercel.json:

{
  "crons": [
    {
      "path": "/api/cron/ping-sitemap",
      "schedule": "0 3 * * *"
    }
  ]
}

The route calls both functions in one request:

// src/app/api/cron/ping-sitemap/route.ts

const [sitemapResults, recentUrls] = await Promise.all([
  pingSitemap(),
  getRecentUrls(7),
]);

const indexNowResults = await pingIndexNow(recentUrls);

getRecentUrls(7) reads from the MDX content layer and returns only URLs modified in the last seven days. No hardcoded lists. No manual updates. When new content is published, the next cron run picks it up automatically.

7. Google and IndexNow

Google has not officially committed to IndexNow.

There are signals they are testing it — some reports of faster indexing when IndexNow pings include Google's endpoint — but nothing is documented or guaranteed.

The practical move is to prepare the infrastructure now.

In the implementation above, Google's entry in INDEX_NOW_TARGETS has enabled: false. When Google officially supports the protocol, changing it to enabled: true is the only code change needed.

The infrastructure is ready. The switch is one line.

Closing Reflection

A sitemap tells search engines that your content exists.

A ping tells them something changed. IndexNow tells them exactly what.

Three layers of the same message, sent with increasing precision.

Most sites only send the first. Some send the second. Very few have all three running automatically.

The gap between "indexed eventually" and "indexed this week" is often just this: whether you built infrastructure that speaks, or infrastructure that waits.