Dev.to WebDev 🛠 Dev 👁 0 📖 8 min read

How to Help Google Understand Who You Are: A Developer's Guide to Person Schema, Wikidata and Knowledge Panels

This article was drafted with AI assistance and reviewed and edited by me. The steps, code and results are from my own portfolio. When someone searches your name, what does Google actually know about you? For most dev

How to Help Google Understand Who You Are: A Developer's Guide to Person Schema, Wikidata and Knowledge Panels

This article was drafted with AI assistance and reviewed and edited by me. The steps, code and results are from my own portfolio.

When someone searches your name, what does Google actually know about you?

For most developers the honest answer is "a pile of unconnected pages": a GitHub profile, a LinkedIn page, a portfolio on a free subdomain, maybe a Medium account. Each one says something about you, but nothing tells Google they are all the same person.

In November 2026 I worked on this for my own name. I'm a software developer from Lucknow, India, and my portfolio is a Next.js site that already had basic Person markup. I created a Wikidata item with sourced facts, and a few days later Google started showing a knowledge panel for "Akshansh Verma, Software developer". Then I audited the rest of my setup and found bugs I didn't know I had.

Akshansh Verma, software developer, standing at an Oratrics event
Akshansh Verma, software developer at Oratrics

I can't promise the same result for you. Google decides who gets a panel, and it never publishes the rules. But every step here makes it easier for search engines to connect the dots, and most of them also fix real SEO bugs. Here's everything I checked and changed, with code.

What a knowledge panel is, and where it gets its data

A knowledge panel is the box on the right of Google's results (or at the top on mobile) that summarises a person, place or thing. It's generated from Google's Knowledge Graph, a database of entities and the facts that connect them.

To show a panel for you, Google has to be confident about three things:

  1. You exist as one entity, not as five unrelated profiles.
  2. Which pages are about you, and which one is your official home.
  3. Facts about you, ideally confirmed by sources you don't control.

The steps below map onto those three things.

Step 1: Pick one page as your "entity home"

Choose one URL that represents you, usually your portfolio homepage, and treat it as the source of truth:

  • Use your full name exactly the same way everywhere ("Akshansh Verma", not "Akshansh V." on one site and a handle on another).
  • Write a short third-person bio and reuse it on every profile: > Akshansh Verma is an Indian software developer based in Lucknow, building full-stack web and React Native applications.
  • Use the same headshot on your site, GitHub, LinkedIn and X.

Search engines love consistency. If every profile repeats the same name, photo and one-line description, it's much easier to merge them into one entity.

Step 2: Describe yourself with Person structured data

Structured data is JSON-LD in your page that says, in machine-readable form, "this page is about this person, and these other pages are also about them".

The important parts are:

  • @id: a stable identifier for you (I use https://my-site/#person). Other schema blocks can then point to the same @id instead of describing a new, separate person.
  • sameAs: links to your other profiles. This is the field that ties everything together.
  • worksFor and alumniOf with their own sameAs links, so Google knows which organisation you mean.

Here is a trimmed version of the component in my Next.js App Router project:

// src/app/components/StructuredData.js
import { PERSON_ID, SITE_URL, WEBSITE_ID } from "../lib/site";

export default function StructuredData() {
  const person = {
    "@context": "https://schema.org",
    "@type": "Person",
    "@id": PERSON_ID,
    name: "Akshansh Verma",
    givenName: "Akshansh",
    familyName: "Verma",
    description:
      "Akshansh Verma is an Indian software developer based in Lucknow, building full-stack web and React Native applications.",
    url: SITE_URL,
    jobTitle: "Software Developer",
    worksFor: {
      "@type": "Organization",
      name: "Oratrics",
      url: "https://oratrics.com",
      sameAs: "https://www.wikidata.org/wiki/Q142155242",
    },
    alumniOf: {
      "@type": "CollegeOrUniversity",
      name: "Khwaja Moinuddin Chishti Language University",
      sameAs: "https://www.wikidata.org/wiki/Q24943422",
    },
    sameAs: [
      "https://www.wikidata.org/wiki/Q142200681",
      "https://www.linkedin.com/in/sde-akshansh/",
      "https://github.com/Akshansh53",
      "https://x.com/SDE_Akshansh",
      "https://medium.com/@akshanshverma53",
    ],
  };

  const website = {
    "@context": "https://schema.org",
    "@type": "WebSite",
    "@id": WEBSITE_ID,
    name: "Akshansh Verma",
    url: SITE_URL,
    author: { "@id": PERSON_ID },
  };

  return (
    <>
      <script type="application/ld+json" dangerouslySetInnerHTML={{ __html: JSON.stringify(person) }} />
      <script type="application/ld+json" dangerouslySetInnerHTML={{ __html: JSON.stringify(website) }} />
    </>
  );
}

Two mistakes I fixed in my own schema while doing this:

  • A fake SearchAction. My WebSite schema advertised a site search (?q={search_term_string}) that didn't exist. Don't describe features you don't have.
  • Spelling drift. My schema spelled my university differently from every other source. Small inconsistencies like that make matching harder.

You can check your markup with Google's Rich Results Test and the Schema Markup Validator.

Step 3: Make sure crawlers can actually read your site

This was the most embarrassing bug I found. My project had a file at public/robot.txt. Notice the missing "s". Crawlers request /robots.txt, so mine returned 404 the whole time.

Worse, the file I thought was protecting my site contained this:

Disallow: /_next/

In a Next.js app, /_next/ holds your JavaScript, CSS and optimised images (/_next/image). Blocking it can stop Google from rendering your page properly and from indexing your images, which are exactly what a knowledge panel needs.

In the App Router you can generate robots.txt from code, which makes the filename impossible to get wrong:

// src/app/robots.js
import { SITE_URL } from "./lib/site";

export default function robots() {
  return {
    rules: { userAgent: "*", allow: "/", disallow: ["/api/"] },
    sitemap: `${SITE_URL}/sitemap.xml`,
  };
}

Step 4: Clean up your sitemap

My old sitemap listed /#about, /#projects and /#contact, with a double slash (//#about) for good measure. Search engines ignore everything after #, so those were just the homepage four times.

Only list real pages. Next.js can also add image entries, which helps Google find your photos:

// src/app/sitemap.js
import { SITE_URL } from "./lib/site";
import { photos } from "./data/gallery";

export default function sitemap() {
  return [
    { url: SITE_URL, lastModified: new Date(), priority: 1 },
    {
      url: `${SITE_URL}/gallery`,
      lastModified: new Date(),
      images: photos.map((p) => `${SITE_URL}${p.src}`),
    },
  ];
}

Step 5: Link your profiles in both directions

sameAs says "these profiles are mine". It's stronger when the profiles agree:

  • Put your website link in the profile of GitHub, LinkedIn, X and Medium.
  • On your own site, mark profile links with rel="me":
<a href="https://github.com/Akshansh53" rel="me noopener noreferrer" target="_blank">
  GitHub
</a>

rel="me" is a long-standing convention for "this link points to another page about me", and some platforms use it to verify ownership.

Step 6: Create a careful, well-referenced Wikidata item

Wikidata is the structured database behind Wikipedia, and it's openly used by search engines and assistants. A Wikidata item for you is one of the clearest machine-readable statements that you exist as an entity.

Be careful here. Wikidata has a notability policy. Items that read like self-promotion, or that only cite the subject's own pages, can be deleted. Add only facts you can back up, and add a source to every statement you can.

The statements that matter most for a person:

Property Example
instance of (P31) human
occupation (P106) software developer
employer (P108) the organisation, with a start time qualifier
educated at (P69) the university, with degree and years
official website (P856) your entity home
GitHub username (P2037), LinkedIn personal profile ID (P6634), X username (P2002) your profiles
image (P18) a freely licensed photo on Wikimedia Commons

Three things I learned the hard way:

  1. Add "retrieved" (P813) to every reference. A reference URL without a date is weaker, and Wikidata's checker flags it.
  2. "Retrieved" dates are in UTC. I'm in India (UTC+5:30), so late-night edits got "tomorrow's" date, and Wikidata flagged every reference as dated in the future. If you edit after 18:30 IST, use the UTC date.
  3. Run the constraint checker. Each statement shows warning icons when something is off. Mine caught an occupation value that wasn't actually an occupation, and a blog URL missing its language qualifier.

Step 7: Give Google good photos of you

Knowledge panels need an image, and Google prefers photos it can confidently tie to you. I added a /gallery page with:

  • Descriptive filenames like akshansh-verma-speaking-at-oratrics-event.jpg, not IMG_2041.jpg.
  • Alt text and visible captions that say who is in the photo and where.
  • ImageGallery structured data where each ImageObject is about the same @id as my Person schema.
const gallery = {
  "@context": "https://schema.org",
  "@type": "ImageGallery",
  url: `${SITE_URL}/gallery`,
  about: { "@id": PERSON_ID },
  associatedMedia: photos.map((p) => ({
    "@type": "ImageObject",
    contentUrl: `${SITE_URL}${p.src}`,
    caption: p.caption,
    about: { "@id": PERSON_ID },
  })),
};

One safety tip: while the page held stock placeholder images, I set it to noindex and kept it out of the sitemap. You don't want Google associating a stranger's photo with your name.

Step 8: Find your Knowledge Graph ID once a panel appears

When a panel shows up, Google has given you an ID that looks like /g/11y7f5mzmh. You can find it in the page source or in the panel's share link (the kgmid= parameter). Then:

  • Open https://www.google.com/search?kgmid=/g/... to confirm it's your panel. This is a stable link to share.
  • Add it to your Wikidata item as Google Knowledge Graph ID (P2671). Don't use the Google search URL as the reference; Wikidata doesn't allow search-result URLs as sources, and external IDs don't need one.
  • Look for "Claim this knowledge panel" at the bottom of the panel. It can take a few weeks to appear for new panels.

What matters more than any of this

Everything above makes you easy to understand. It doesn't make you notable. The strongest signal for a knowledge panel, and for keeping your Wikidata item alive, is independent coverage: articles about you, talks listed on event sites, interviews, and results pages that mention your name.

So after the technical work, the next step is the human one: write, speak, and build things other people write about.

Checklist

  • ✅ One entity home with a consistent name, photo and third-person bio
  • ✅ Person JSON-LD with a stable @id and a complete sameAs list
  • ✅ robots.txt reachable, and not blocking /_next/
  • ✅ Sitemap with real URLs only, plus image entries
  • ✅ Your website linked from every profile, and rel="me" on your profile links
  • ✅ A well-referenced Wikidata item, with retrieved dates in UTC
  • ✅ A gallery page with descriptive filenames, captions and ImageGallery schema
  • ✅ Your Knowledge Graph ID added to Wikidata once you have one

Akshansh Verma is a software developer at Oratrics in Lucknow, India, building full-stack web and React Native applications and moving into AI engineering. You can find his work at sde-akshanshverma.vercel.app and on GitHub.

📰 Read the original article on Dev.to WebDev

Originally published by Dev.to WebDev. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.