Search engines and AI systems have a problem your content strategy should care about: the web is drowning in anonymous, machine-generated, expertise-free text, and the systems ranking and citing content are working harder than ever to figure out who is actually behind it. Google’s quality frameworks put experience, expertise, authoritativeness, and trust at the center of content evaluation — with “who created this” as an explicit assessment question. AI answer engines deciding which sources to cite lean on the same signals. And most business sites answer the question with a byline that says “Admin,” an author page that doesn’t exist, and structured data that stops at the organization’s logo.
Article and author schema won’t transmute weak content into strong — no markup does, and the persistent myth that schema is a ranking dial produces exactly the over-engineered, dishonest markup that gets ignored. What the markup does is subtler and increasingly valuable: it makes your genuine expertise machine-readable. A properly marked-up article declares its author as a Person entity; the Person connects — via a real author page and sameAs links — to the credentials, profiles, and body of work that prove the expertise exists; dates declare freshness honestly; the publisher connects it all to the business entity. For a service business whose competitive advantage is that a licensed master plumber, an actual attorney, or a practicing accountant writes (or meaningfully reviews) the content, this layer is how that advantage becomes legible to every system now deciding what to rank, quote, and recommend.
This guide is the implementation: what Article and Person schema actually do (and the honest limits), the entity architecture — article → author → author page → the corroborating web — the field-by-field build for both types, the author-page anatomy that makes the markup’s claims verifiable, the expert-review pattern for content written by staff and reviewed by credentialed professionals, the honesty rules (fake authors and inflated credentials are worse than none), and the audit for what you’ve already published.
Article and author schema make your expertise machine-readable — they don’t rank weak content, but they connect your content to verifiable expert identities in the way quality systems and AI engines increasingly read. The architecture: Article schema (headline, truthful dates, image, publisher) whose author is a Person entity — not a string — with url pointing to a real author page and sameAs linking the person’s corroborating profiles (LinkedIn, licenses/registries where linkable, industry profiles); ideally the Person is defined once with an @id and referenced from every article. The author page is the proof layer: bio with specific credentials, experience, license numbers where applicable, photo, the person’s article archive — the page that makes the markup’s claims checkable. Expert-reviewed content uses the honest pattern: author = writer, reviewedBy = the credentialed professional, with a visible review line on the page. Honesty rules: real people only, credentials as held, dates truthful (dateModified only on substantive updates) — fabricated authors are a trust liability across every system that checks. Markup mirrors visible content; it never claims what the page doesn’t show.
What the Markup Actually Does — and Its Honest Limits
- Eligibility and understanding, not ranking: Article schema helps systems parse what the page is (an article, by whom, when, from what publisher) and supports presentation features; Google’s own documentation is direct that adding author markup doesn’t itself boost rankings. The value is representational: your E-E-A-T story exists on the page; the markup makes it parseable at scale.
- Entity establishment: the deeper play is helping systems resolve your experts as entities — this Person, with this name, this role, these credentials, this body of work — disambiguated from strangers with the same name and connected across everything they’ve written. Entity clarity is what lets an author’s accumulated credibility attach to each new piece.
- The AI-citation angle: answer engines choosing what to quote and recommend weigh source credibility, and machine-readable authorship — served in the initial HTML, per the rendering rules — is among the legible credibility inputs. A cited-by-AI future favors content whose expertise is checkable by machines that don’t read prose nuance.
- The limits, stated plainly: markup on thin content marks up thin content; a Person entity for a fabricated expert is a machine-readable lie; and none of this substitutes for the visible layer — the byline, bio, and credentials a human reader sees. Schema mirrors the page; the page carries the trust.
The Entity Architecture: Article → Person → Page → Web
Think of it as a chain of claims, each link verifiable at the next:
- The article claims an author: Article schema’s
authorproperty holds a Person object (never a bare string, never the Organization when a human wrote it) withname,url, and ideally ajobTitle. - The Person claims an identity: the
urlpoints at the author’s page on your site;sameAsarrays the corroborating profiles — LinkedIn, relevant industry directories, a license-registry profile where one has a stable URL, speaker/association pages. Define the Person once, site-wide, with a stable@id(e.g.https://example.com/team/jane-smith#person) and reference that@idfrom every article’s author field — one entity, many citations, instead of forty subtly different copies. - The author page proves the claims: the page the
urltargets carries the human-readable evidence (anatomy below) and its own ProfilePage/Person markup — the same entity, same@id. - The web corroborates: the
sameAsdestinations actually exist, name the same person, and support the credentials — the external layer no on-site markup can fake, which is exactly why systems weigh it.
The implementation detail that separates clean author graphs from noisy ones: give each expert a single canonical Person definition — on their author page, with a fragment @id — and have every article’s author property reference that @id rather than re-declaring name-and-url inline. Benefits: consistency by construction (no drift across forty articles when a title changes), a stronger disambiguation signal (every article points at literally the same node), and one place to maintain credentials and sameAs links. Most SEO plugins approximate this when author profiles are filled in properly — the audit is confirming the emitted JSON-LD actually links articles to the same entity rather than emitting orphaned per-page Person strings.
The Field-by-Field Build
| Property | Guidance |
|---|---|
Article: @type | Article for editorial content generally; BlogPosting for blog posts; NewsArticle only for actual news. Over-specifying buys nothing; misclassifying invites distrust of the rest. |
headline | The actual title — matching the visible H1, not a keyword-enriched alternate. |
datePublished / dateModified | ISO 8601, truthful, matching the visible dates — dateModified changes on substantive updates only, per the refresh integrity rules; gamed dates are the fastest way to teach systems your markup lies. |
image | The article’s representative image(s), adequate resolution — presentation surfaces use these. |
author | Person object or @id reference; name as bylined; url to the author page; jobTitle where meaningful (“Master Plumber, License M-38412” beats “Content Team”). Multiple authors: an array of Persons. Organization as author only when content genuinely has no individual author. |
publisher | Your Organization entity (also @id-referenced ideally) with name and logo — the business-level trust anchor the articles inherit. |
Person: sameAs | The corroboration array — LinkedIn first for most professionals, plus industry directories, association member pages, license registries with stable profile URLs, notable publication author pages. Quality over quantity: three real, checkable profiles beat ten dead links. |
| Person: credentials | jobTitle, worksFor (your Organization @id), and where genuinely applicable hasCredential/knowsAbout — used honestly and sparingly; the visible bio carries the detail, the markup carries the pointers. |
reviewedBy | The expert-review pattern’s key property — below. |
The Author Page: Where the Claims Become Checkable
The markup’s url is a promise; the author page keeps it. The anatomy that does the work: a specific bio — years in the trade, the license with its number where licensure is public (verifiable beats impressive), the specializations, the real career facts a skeptic could check; a real photo (the same one across their profiles helps entity resolution and human trust alike); the article archive — everything they’ve written or reviewed on your site, which is both user navigation and the on-site body-of-work signal; the corroborating links, visibly — the same LinkedIn and registry links the sameAs declares, clickable for humans; and ProfilePage markup wrapping the canonical Person definition. Keep author pages linked into the site — from every byline, from the about page — indexed, and in the sitemap: an orphaned author page undercuts the very chain it anchors.
The Expert-Review Pattern: Honest Markup for How Content Actually Gets Made
Most service-business content isn’t typed by the license-holder — a marketer or writer drafts; the plumber, attorney, or CPA reviews, corrects, and approves. The honest pattern, increasingly standard in health and finance publishing, marks up exactly that: author = the actual writer (a real person, with their own modest author page — a professional writer is a legitimate identity, not something to hide), reviewedBy = the credentialed expert as a full Person entity with the strong credentials, and a visible review line on the page — “Reviewed by Jane Smith, Master Plumber (License M-38412), on [date]” — because the markup mirrors the page, never replaces it. This pattern gets you the expert-trust signal without the lie of ghost-bylining the expert on words they didn’t write — and it makes the review step a real editorial process with the expert’s name on the outcome, which tends to improve the content itself, which was always the point.
The temptation the AI-content era industrialized: invented expert personas — stock-photo faces, fabricated credentials, generated bios — bylining machine-written content, with schema dutifully declaring the fiction. Understand the exposure: the corroboration layer is checkable (a ‘master electrician’ with no license record, no LinkedIn, no history anywhere is a one-search debunk), publishers have been publicly burned by exactly this pattern, quality systems explicitly target it, and the reputational failure mode — a customer or competitor discovering your expert doesn’t exist — poisons trust in everything true you’ve published. The adjacent lesser sins carry the same trajectory: real employees credited with inflated credentials, the owner bylined on content nobody reviews, degrees and licenses implied but not held. The clean alternatives are all available: the review pattern for staff-written content, honest writer bylines, organization authorship where no individual applies. If the marketing plan requires an expert who doesn’t exist, the problem isn’t markup — it’s the plan.
The Retrofit: Auditing What’s Already Published
- Inventory the current state: crawl for existing Article/Person markup (crawlers extract JSON-LD); catalog byline reality — how many posts say “Admin,” a defunct employee, or nothing; validate a sample through the rich-results and schema validators.
- Build the entity layer first: author pages for each real expert and writer (with the canonical Person definitions), the Organization entity confirmed, the review-pattern policy decided.
- Fix by template, then by exception: most CMSs emit article markup from the author profile system — assigning posts to real author accounts with completed profiles fixes the archive wholesale; the exceptions (guest posts, departed staff, genuinely authorless pages) get individual decisions. Departed experts’ content: keep the truthful historical byline (they did write it) with the author page noting their tenure, or re-review under a current expert with
reviewedByupdated — never silently reassign bylines. - Prioritize by stakes: money-topic content (the pages where expertise most matters to readers and evaluators — anything health-, finance-, legal-, or safety-adjacent in your trade) gets the full treatment first; the 2019 company-picnic post can wait.
- Verify in the wild: validator-clean on the templates, entities resolving (one @id per person), and the markup present in the initial HTML — server-side, not tag-manager-injected, per the delivery rules.
5 Common Article/Author Schema Mistakes
- Author as a string.
"author": "John"declares nothing resolvable — Person objects with URLs, or the chain never starts. - Markup pointing at author pages that don’t exist. The
urlpromise broken at the first click — build the proof layer before the claims layer. - Forty divergent copies of the same person. Per-page inline Persons drifting in name, title, and URL — the @id pattern exists to prevent exactly this.
- Dates gamed, headlines enriched, credentials inflated. Each dishonest field teaches evaluators to discount the honest ones — markup integrity is all-or-nothing per site.
- Schema-first thinking. Markup on anonymous thin content is lipstick on a byline — the visible layer (real experts, real bios, real review lines) comes first; the JSON-LD mirrors it.
Frequently Asked Questions
Will adding author schema improve my rankings?
Not directly, and it’s worth being precise about the mechanism you’re actually investing in. Google states plainly that markup itself isn’t a ranking boost — the systems use it to understand content, not to reward its presence. The realistic value chain: structured authorship helps systems resolve who created your content and connect it to that person’s corroborated credibility; creator trustworthiness is an explicit part of how content quality gets assessed (the E-E-A-T frameworks, the quality-rater guidance on ‘who created this’); and machine-readable, verifiable expertise is among the inputs when AI systems choose what to cite. So the honest claim is: schema makes real expertise legible, and legible expertise participates in evaluations that do move outcomes — rankings on expertise-sensitive topics, citation in AI answers, rich presentation. What produces the disappointment stories is inverting the order: markup added to anonymous or thin content, expecting the JSON-LD to conjure the trust the page doesn’t contain. Sequence it right — real experts visibly involved, proof-layer author pages, then the markup mirroring it — and the schema is the cheap final step of a trust asset; sequence it wrong and it’s decoration on the problem.
Our blog posts are written by a marketing person and checked by our licensed owner. Who should the author be?
Use the review pattern exactly as your process works, because the honest version is also the strongest one available to you. Author: the marketing writer, as a real Person entity with a modest author page — professional writers are legitimate authors, and hiding them behind the owner’s byline is a small fabrication with the usual fabrication risks (the owner ‘authoring’ forty posts in a voice that isn’t theirs is noticeable, and misattributing authorship on licensed-advice content can have professional-conduct dimensions in some fields). ReviewedBy: the owner, as the full-credential Person entity — license, title, sameAs corroboration — with a visible review line on each post (‘Reviewed by [name], [credential], [date]’). This pattern puts the expert trust signal exactly where it’s true — a credentialed professional stands behind the content’s accuracy — while keeping every claim checkable. Two operational notes: make the review real (the owner’s name on the line means they actually read and approved it — which is also your content-quality mechanism), and if the owner does genuinely write some pieces, byline those honestly as author; a mixed archive where attribution tracks reality is precisely the pattern trust systems and human readers reward.
What should go in sameAs — and does it actually matter?
SameAs is the entity-resolution property: it tells systems ‘this Person node is the same individual as these profiles elsewhere,’ which does two jobs — disambiguation (your Jane Smith versus the thousands of others) and corroboration (the places where the credentials the markup implies can be checked). What earns a slot: the person’s LinkedIn (the workhorse for professionals), relevant industry-directory and association-member profiles, a state license-registry profile where the registry offers stable per-person URLs, author pages on notable publications they’ve written for, speaker profiles from real events, and — sparingly — active professional social profiles. What doesn’t: dead links, empty profiles created last week to fill the array, generic company pages, and anything that names a different or ambiguous person — a sameAs that fails verification is worse than a shorter honest list. Does it matter? Proportionately: it’s one input into entity resolution, not a lever — but it’s the input that makes the rest of the chain checkable, and for the AI-citation use case, checkable is the property being selected for. Practical bar: three to five live, unambiguous, credential-relevant links per expert, maintained (a quarterly click-through of every sameAs across the team is a ten-minute audit), and mirrored as visible links on the author page so humans get the same corroboration machines do.
Should the article's author ever be our company instead of a person?
Sometimes — the schema explicitly supports Organization authors, and the honest test is whether an individual meaningfully created the content. Legitimate organization authorship: genuinely collective pages (service descriptions, company announcements, documentation assembled by many hands), data or research published as the firm’s work, and content where no individual’s expertise is the point. But for the content this whole trust architecture exists for — advice, guides, expertise-driven articles on your money topics — individual authorship (or the writer-plus-reviewedBy pattern) is meaningfully stronger, because the evaluation question being asked is ‘what human expertise stands behind this advice,’ and ‘the company’ is a weaker answer than ‘this licensed professional, checkable here.’ The failure mode to avoid is organization-authorship as a dodge: bylining everything to the brand because building author pages felt like work, or because the real answer (nobody with credentials was involved) is uncomfortable — the second case being a content-process problem the markup choice merely reveals. A sensible portfolio: Organization for the corporate and collective layer, named experts (with the full entity treatment) on everything where expertise is the product — which, for a service business publishing to win trust, should be most of the article library.
We have 200 old posts bylined 'Admin.' Is retrofitting worth it, and where do we start?
Worth it — and cheaper than it looks, because the fix is mostly systemic rather than per-post. The CMS reality: article markup and bylines usually flow from author accounts, so the bulk move is creating real author profiles (the experts and writers who actually produced or will re-review the content), completing them (bio, photo, links — which most SEO plugins translate into Person markup automatically), and reassigning posts from ‘Admin’ to the true authors in batches — a data operation, not two hundred editing sessions. Where attribution is genuinely unknown or the author is long gone: assign honestly (organization authorship, or current-expert review with reviewedBy and a visible review line as part of a content-refresh pass) rather than guessing bylines onto people. Prioritize by stakes and traffic: the money-topic and top-traffic posts get the full treatment first — true attribution, expert review where the topic warrants it, author-page links — because those are the pages where evaluators and readers most weigh the ‘who’; the long tail can inherit the systemic fix on the CMS timeline. Natural pairing: run the retrofit alongside the content-decay triage — posts getting a substantive refresh anyway are the perfect moment to add real review lines and current attribution, and posts headed for consolidation or removal don’t need retrofitting at all. The end state to verify: every indexed article resolves to a real Person or an honest Organization author, every Person resolves to a live author page, and the validator agrees — at which point new content inherits the system and the problem stays solved.
Is your real expertise invisible to the systems that check for it?
We’ll build the full entity layer — author pages with verifiable credentials, canonical Person definitions, the reviewedBy pattern for your editorial process — and retrofit the archive so every article testifies to the expertise your business actually has.
Get an E-E-A-T Audit Explore SEO Services