DEV Community: Momen Abdelhafez

Get Indexed first!

Momen Abdelhafez — Fri, 03 Jul 2026 23:07:55 +0000

Momen Abdelhafez

Jul 2

If You're Not Indexed, No AI Model Will Cite You

#seo #geo #ai #webdev

3 min read

If You're Not Indexed, No AI Model Will Cite You

Momen Abdelhafez — Thu, 02 Jul 2026 12:11:50 +0000

Here's a sentence that should worry anyone building content, docs, or a product site right now:

If Google hasn't indexed your page, no AI model can cite it. Not ChatGPT, not Perplexity, not Google's own AI Overviews. It doesn't exist for them.

This isn't a hot take — it's just how these systems are built. And it's a bigger deal than it sounds.

Where AI Answer Engines Actually Get Their Information

AI answer engines don't have some independent, mystical knowledge of the web. They rely on the same underlying infrastructure search engines have used for decades:

Discover → Crawl → Index → (eligible to rank AND/OR be cited by AI)

Retrieval-augmented systems, Google's AI Overviews, and answer engines like Perplexity all pull from indexed content — either through live retrieval or search-grounded generation. Indexing is the shared gate. Skip it, and you're not in the running for either channel: not classic rankings, not AI citations.

A page that's published but not indexed isn't "ranking low" or "getting cited rarely." It's at zero. Completely absent from both systems.

Why This Is Easy to Miss

Most people assume "I published it" ≈ "it's now part of the internet's knowledge." It isn't, until:

Google (or another crawler) discovers the URL
Crawls it
Actually stores it in the index (crawled ≠ indexed — plenty of pages get crawled and never indexed)
Common reasons pages silently sit unindexed:
No internal links pointing to them (orphaned pages)
Client-side rendering with no SSR/prerendering (crawler sees an empty shell)
Thin or duplicate content Google decides isn't worth storing
Accidental noindex tags or robots.txt blocks
The site or page is simply too new to have been crawled yet
Any one of these silently removes you from the AI citation pool, with zero error message telling you it happened.

What Actually Changes Your Odds of Being Cited

Once you're indexed, the "GEO" (Generative Engine Optimization) layer starts to matter:

Answer-shaped content — concise, direct statements near the top of a page, easy for retrieval systems to extract cleanly
Structured data / schema — helps a retrieval step understand what your page is actually about
Clean, quotable phrasing — content that's easy to lift a clean sentence from tends to get lifted But none of this does anything if step one — indexing — never happened. You can't optimize your way into a citation from a page that isn't in the index at all.

The Practical Fix

Don't assume a page is indexed just because you hit publish. Confirm it. I got into the habit of checking this after every significant publish or update, and eventually automated it with GoogleIndexer — free, submits URLs in bulk and tracks each one's indexing status so I know for certain a page has cleared that first gate before I bother thinking about GEO formatting on top of it.

TL;DR

No indexing = no citations, from any AI model. It's a hard gate, not a ranking factor.
Crawled ≠ indexed — a page can be seen by a bot and still never make it into the index.
GEO tactics (answer-shaped content, schema) only matter after indexing — they don't substitute for it.
Confirm indexing instead of assuming — GoogleIndexer does this for free if you want it automated. Is anyone else auditing old content specifically for AI-citation eligibility, separate from traditional SEO audits? Curious what that workflow looks like for other people.

GEO Is Eating SEO's Lunch (Sort Of) — What Devs Need to Know

Momen Abdelhafez — Thu, 02 Jul 2026 12:01:39 +0000

If you've noticed more of your traffic coming from ChatGPT, Perplexity, or Google's AI Overviews lately instead of classic blue-link clicks, you're seeing GEO play out in real time. It's worth understanding as a dev, because it changes some assumptions about what "being findable" even means.

What GEO Actually Is

GEO — Generative Engine Optimization — is the practice of optimizing content so it gets surfaced and cited by AI answer engines, instead of (or alongside) ranking in a traditional search results page.

The core difference from classic SEO:

	SEO	GEO
Target	Search result pages	AI-generated answers
Success	Ranking high in a list	Being quoted in the response
Channels	Google, Bing	ChatGPT, AI Overviews, Perplexity

It's a real shift in where the click comes from and how your content gets used. But here's the part that gets lost in a lot of the GEO hype content out there:

GEO Doesn't Replace SEO's Foundation — It Depends on It

AI answer engines don't have some separate, independent knowledge graph. They pull from content that's already been crawled and indexed by traditional search infrastructure. That means:

Discover → Crawl → Index → (eligible to rank OR be cited by AI)

Indexing is a shared prerequisite. If Google hasn't crawled and indexed your page, it doesn't exist for ranking and it doesn't exist for an AI engine to cite. There's no GEO shortcut around that gate.

So a lot of "GEO strategy" content that talks about clarity, structure, and authority is really just... good SEO, repackaged. The stuff that's genuinely GEO-specific:

Answer-shaped content. Concise, direct answers near the top of a page (AI engines favor extractable snippets over long buildup).
Structured data / schema. Makes it easier for an LLM's retrieval step to parse what your page is actually about.
Clear source attribution patterns. Content that's easy to quote cleanly tends to get quoted. But none of that matters if the page was never indexed in the first place.

Practical Takeaway for Devs

If you're building something you want cited by AI tools eventually, the actual checklist is boring and familiar:

Ship pages that are crawlable (no accidental noindex, no JS-only rendering blocking content — see my last post on that).
Confirm they're actually indexed — don't assume.
Then worry about answer-shaped formatting and schema for the GEO layer on top. Step 2 is the one people skip. I run my own pages through GoogleIndexer after publishing — free tool, submits URLs in bulk and tracks indexing status — mostly so I'm not guessing whether the foundation is even in place before I bother optimizing for the AI layer.

TL;DR

GEO = optimizing for AI answer engines (ChatGPT, AI Overviews, Perplexity) instead of just search rankings.
It's real, but it sits on top of the same foundation as SEO: your page has to be crawled and indexed first.
If a page isn't indexed, it can't be cited — GEO doesn't skip that step.
Nail indexing and crawlability first; answer-shaped content and schema are the actual GEO-specific layer on top.
Confirm your pages are actually indexed instead of assuming — GoogleIndexer does this for free if you want it automated. Anyone tracking AI-referral traffic separately yet? Curious what tools people are using to attribute clicks from AI Overviews vs Perplexity vs ChatGPT.

Bulk Indexing Your URLs, Automated (No More One-by-One API Calls)

Momen Abdelhafez — Wed, 01 Jul 2026 21:23:33 +0000

If you've ever tried to get more than a handful of URLs indexed by Google, you already know the pain: Google's Indexing API works fine for one page — and then falls apart the moment you're dealing with hundreds.

Here's what that actually looks like, why it breaks down at scale, and how I ended up automating it.

The One-URL Version Works Fine

Google's Indexing API is straightforward for a single request:

async function submitUrl(url) {
  await jwtClient.authorize();
  const res = await fetch(
    'https://indexing.googleapis.com/v3/urlNotifications:publish',
    {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${jwtClient.credentials.access_token}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ url, type: 'URL_UPDATED' }),
    }
  );
  return res.json();
}

Call it once, get a 200, move on. Nice and clean.

Where It Breaks Down

Now do that for 500 URLs — new blog posts, product pages, backlinks you built last week. A few problems show up fast:

Quota limits. The API caps requests per day. Loop over 500 URLs naively and you'll hit the ceiling.
No batch status view. The API tells you a request was accepted — not whether the URL is actually indexed. Those are different things.
Retry logic. Some submissions fail silently or need a re-try. You end up building your own queue.
Tracking over time. Indexing isn't instant. You need something polling status days later, not just firing requests once. None of this is hard, exactly — it's just infrastructure you have to build and maintain for a problem that isn't your core product.

What I Built to Skip This

I ended up wrapping all of this into GoogleIndexer — free, handles the batch/quota/retry/tracking problem so you don't have to:

Paste or upload a list of URLs — submits the whole batch
Tracks each URL's status automatically (pending → indexed)
Confirms the moment each one goes live in search
Works for pages and backlinks alike It's the same underlying API problem, just with the queueing and status-polling already handled.

When to Roll Your Own vs Use a Tool

Honestly — if you're only ever submitting a handful of URLs, the raw API snippet above is all you need. Where a tool like this starts to matter is once you're publishing or building links at real volume and don't want to own a whole submission pipeline just to know whether your content is actually discoverable.

If you want to try it: google-indexer.com — free, no credit card.

Would love to hear how others here are handling bulk indexing — anyone built their own queue system for this, or found other tooling that works well?

Get Indexed on Google for free and in less than 24h!

Momen Abdelhafez — Wed, 01 Jul 2026 21:20:05 +0000

Momen Abdelhafez

Jul 1

Why Your Pages Aren't Showing Up on Google (And How I Fixed It)

#seo #webdev #googleindexing

2 min read

Why Your Pages Aren't Showing Up on Google (And How I Fixed It)

Momen Abdelhafez — Wed, 01 Jul 2026 21:05:46 +0000

You ship a page. You check Google a few days later. Nothing.

If you've built a product, a blog, or a side project and wondered why it's invisible in search, this post is for you. It's not about "SEO tricks" — it's about a step almost every dev skips: confirming your pages are actually indexed.

Publishing ≠ Indexed

This trips up a lot of technical people, because it feels like it should just work. It doesn't. Before Google can show your page in search results, it goes through three stages:

Discovery — Google learns the URL exists
Crawling — Googlebot fetches and reads the page
Indexing — Google stores it in its searchable database Only step 3 makes you findable. A page that's live on your server but not indexed is functionally invisible to Google — zero impressions, zero clicks, zero rankings. Same goes for backlinks: a link on a page that isn't indexed passes no authority at all.

The Real Fix: Google's Indexing API

Google actually offers a way to skip the wait — the Indexing API. Instead of hoping Googlebot finds your page on its normal crawl schedule, you notify Google directly that a URL is ready.

The basic flow:

# 1. Enable the Indexing API in Google Cloud Console
# 2. Create a service account, download the JSON key
# 3. Add the service account as an Owner in Search Console
# 4. Authenticate and POST to the endpoint

const { google } = require('googleapis');

const jwtClient = new google.auth.JWT(
  serviceAccount.client_email,
  null,
  serviceAccount.private_key,
  ['https://www.googleapis.com/auth/indexing'],
  null
);

async function submitUrl(url) {
  await jwtClient.authorize();
  const res = await fetch('https://indexing.googleapis.com/v3/urlNotifications:publish', {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${jwtClient.credentials.access_token}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ url, type: 'URL_UPDATED' }),
  });
  return res.json();
}

This works well — for one or two URLs. Where it gets annoying: managing service accounts, handling quotas, writing your own status-tracking logic, and checking whether each URL actually made it into the index (submitting ≠ indexed, same problem as before, just one layer down).

What I Built Instead

I got tired of wiring this up manually every time, so I built GoogleIndexer — a free tool that wraps the whole workflow:

Submit URLs (and backlinks) in bulk — no API setup required
Automatic status tracking per URL — pending → indexed
Clear confirmation when a page actually goes live in search It's the same underlying problem — submit, then verify — just without writing and maintaining the plumbing yourself. Free, no credit card, built because I needed it for my own projects.

TL;DR

Publishing a page doesn't mean it's indexed. Confirm, don't assume.
Google's Indexing API lets you request indexing directly instead of waiting on the crawl schedule.
Setting it up yourself is doable but has real overhead (auth, quotas, tracking).
GoogleIndexer handles bulk submission + tracking for free if you'd rather skip the setup. Curious how others here handle indexing at scale — anyone rolled their own tracking system, or found a good OSS option?