Andrew Parra ES

Guides · SEO and AI search

Rank for your own name

Tie your site, your photo and your real profiles to one person in structured data, prove you own the site, and give search engines pages with enough depth to show for your name.

Reading time
8 min read
Updated
Nov 19, 2026
Part of
the 66-guide pack

When someone searches my name, I want the first result to be my own site and not a stranger who shares it. In November I asked Claude to help with that on andrewparra.com. The work turned out to be small and mechanical: one block of structured data on every page, a verified Search Console property, a sitemap, a few indexing requests, more depth on thin pages, and links from the profiles I already have.

None of it guarantees a ranking. Google decides that, on its own schedule. What you can do is remove every reason for it to be unsure which pages are about you. This guide is that list, in the order I did it.

Every page points at one person

/ (home)WebPage + Person + WebSite
/aboutProfilePage, mainEntity
/work, /lab/…WebPage, about
→
@id: example.com/#personname, photo, description
→
sameAs: LinkedIn (yours) sameAs: your own site not: a directory you can't edit

Example timeline after shipping

day 1   meta tag verified                ok
day 1   sitemap submitted                Couldn't fetch (file serves 200; wait)
day 1   indexing requested: /, /about, /es/   queued
weeks   check Performance for your name  no guarantee
One stable id ties every page, your photo and the profiles you own to the same person; the rest is verifying, submitting and waiting.

1. Give yourself one id

Search engines read JSON-LD, a small script block in each page's <head> that describes the page in schema.org terms. The trick for a personal site is to describe yourself once, give that description a stable @id, and point every page at it.

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "WebPage",
      "@id": "https://example.com/work#page",
      "url": "https://example.com/work",
      "name": "Work | Jane Example",
      "inLanguage": "en",
      "isPartOf": { "@id": "https://example.com/#website" },
      "about": { "@id": "https://example.com/#person" }
    }
  ]
}

The #person fragment is just a name. It never has to resolve to anything on the page. What matters is that every page uses the same string, so all of them say "this page is about that one person."

2. Describe the person on home and About

Two pages carry the full description: the home page and the About page. The home page also declares the site itself.

{
  "@type": "Person",
  "@id": "https://example.com/#person",
  "name": "Jane Example",
  "url": "https://example.com/",
  "image": "https://example.com/assets/jane-example-2026.jpg",
  "description": "Jane Example is a product designer in Example City who builds tools with the Claude API.",
  "jobTitle": "Product Designer",
  "knowsAbout": ["Product design", "Claude API", "Web development"],
  "knowsLanguage": ["en", "es"],
  "sameAs": [
    "https://www.linkedin.com/in/jane-example/",
    "https://www.jane-example-studio.com"
  ]
},
{
  "@type": "WebSite",
  "@id": "https://example.com/#website",
  "url": "https://example.com/",
  "name": "Jane Example",
  "publisher": { "@id": "https://example.com/#person" }
}

On the About page, change the page's own type from WebPage to ProfilePage and use mainEntity instead of about. A profile page is literally a page whose main subject is one person.

Write the description the way you would want a search result to read: your name, what you do, where. Use the same photo file that appears on the page, and give it a new file name when you replace it.

3. Only list profiles you control in sameAs

sameAs tells search engines "these other pages are also me." It is tempting to list every directory or article that mentions you. I listed two: my LinkedIn profile and my consulting site. Both are accounts I own and can edit. If a profile you link to drifts out of date, or belongs to someone else, you are telling Google that person is you.

Keep the list short and boring. You can add a profile later once it is real and maintained.

4. Generate it in the build, never by hand

My site has a tiny Python build that wraps every page in a shared head. The Person object lives once in that script, and the build writes the right graph into every page: WebPage plus the person's id on most pages, ProfilePage on About, the full Person and WebSite on home and About. If I hand-edited 40 HTML files, one of them would drift.

graph = [{
    "@type": "ProfilePage" if path == "/about" else "WebPage",
    "@id": url + "#page", "url": url, "name": title, "inLanguage": lang,
    "isPartOf": {"@id": SITE_ID},
    ("mainEntity" if path == "/about" else "about"): {"@id": PERSON_ID},
}]
if path in ("/", "/about"):
    graph += [PERSON, WEBSITE]
head += f'<script type="application/ld+json">{json.dumps({"@context": "https://schema.org", "@graph": graph})}</script>'

While you are in the head, add the basics if they are missing: a <title> with your name, <meta name="author">, a canonical link, and hreflang alternates if you publish a second language. Paste one built page into Google's Rich Results Test or the schema.org validator before you ship.

5. Prove you own the site in Search Console

Google Search Console is where you see how Google reads your site. Add a URL-prefix property for your domain and choose the HTML meta tag method. Google gives you one tag:

<meta name="google-site-verification" content="PASTE-YOUR-CODE-HERE">

I keep the code in one constant in the build and print the tag on the home page only. Ship, then press Verify. Keep the tag forever. Removing it can unverify the property later. The code isn't secret, and I still keep it out of guides and logs.

If you also want Bing, its Webmaster Tools can import a property that is already verified in Search Console, according to Microsoft's own getting-started post.

6. Submit the sitemap and request indexing

A sitemap lists every page with its last-changed date. My build writes it on every run from each page's header, so it can't fall behind.

<url><loc>https://example.com/about</loc><lastmod>2026-11-18</lastmod></url>

Point to it from robots.txt with a Sitemap: line, then submit it under Sitemaps in Search Console. After that, use URL Inspection on your two or three most important pages (home, About, and the home page of a second language if you have one) and press Request indexing. You get a limited number of these requests, so spend them on the pages that answer "who is this person."

7. Put depth on every page

Structured data says who a page is about. It does not make a thin page worth showing. In the same pass I made every page fuller: a longer About with how I got here, what I'm looking for and where else to find me, a short "About" section on the home page, and on each project page a timeline, what I learned and related links. The facts on those pages match the description in the JSON-LD, so the two tell one story.

Google's own guidance says structured data should match what the visible page says. Don't put claims in JSON-LD that a reader can't see.

8. Link to the site from profiles you already have

Search engines find you through links as well as sitemaps. I added the site and the guides to the Featured section of my LinkedIn profile, so the profile listed in sameAs links back to the site that names it. That closes the loop: the site says "this LinkedIn is me" and the LinkedIn says "this site is mine."

Do the same anywhere you control: a GitHub profile, a speaker page, an email signature.

What to watch

  • "Couldn't fetch" on day one. When I submitted my sitemap, Search Console showed "Couldn't fetch" the same day, even though the file was served with a 200 and an XML content type. Check the file yourself with curl -I, then give it time before you change anything.
  • No promise on timing. A new page can take a while to be crawled and indexed (check Google's current help for timing), and nothing guarantees your page ranks first. I haven't seen a result yet that I can report. Check the Performance report for searches of your name after a few weeks, not after a few hours.
  • Your employer and clients are part of your story. My Person description names where I work, and I only published depth about that work after the company approved it. Get that yes before you describe someone else's business in structured data or on a page.

Checklist

  • One Person object with a stable @id, defined once in the build.
  • Every page carries a WebPage that points at the person; About is a ProfilePage; home and About carry the full Person and WebSite.
  • sameAs lists only profiles you own and keep current.
  • Search Console verified with the meta tag on the home page, and the tag stays.
  • The build writes the sitemap; it is in robots.txt and submitted.
  • Indexing requested for home, About and any second-language home.
  • Every page has real depth that matches the structured data.
  • Profiles you control link back to the site.

Want the rest?

This is one of 66 guides. The full pack is pay what you want, from a coffee up.