DEV Community: Elena Mercer

How To Audit an Outsource SEO Company: A Technical Guide for Developers

Elena Mercer — Sat, 26 Sep 2026 01:41:08 +0000

Most software engineers dread the moment leadership hires an external marketing vendor. Non-technical agencies often dump bloated tracking scripts into your codebase and demand arbitrary URL rewrites. You end up cleaning up their performance regressions while organic pipeline remains flat.

If your company decides to hire an outsource SEO company, engineering must establish technical guardrails upfront. You need partners who understand server-side rendering, hydration costs, and structured entity graphs rather than basic meta-tag insertion.

Here is how developers and technical leads should audit an external search partner's technical competence.

1. Do They Understand Headless and SSR Rendering?

Many outsourced vendors still treat modern web apps like static WordPress sites from 2012. They fail to understand how Googlebot processes JavaScript rendering queues, client-side hydration, and edge-rendered frameworks.

If an agency complains that dynamic routes cannot rank without third-party plugins, replace them immediately. A qualified partner audits your raw DOM against the hydrated DOM to identify client-side rendering bottlenecks.

Ask prospective partners how they debug hydration mismatches and inspect rendered DOM snapshots via headless Chromium.

2. Inspecting Structured Data and JSON-LD Implementation

Commodity agencies typically install bloated plugins that output generic, invalid microdata into the document head. Modern technical search requires clean, programmatic JSON-LD injected at the template or edge layer.

Your partner must supply valid schema models tailored to your specific data graph. Below is an example of the minimal JSON-LD architecture an agency should provide for a B2B service entity:

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Organization",
      "@id": "https://example.com/#organization",
      "name": "Acme Engineering",
      "url": "https://example.com",
      "sameAs": [
        "https://www.linkedin.com/company/acme-engineering",
        "https://github.com/acme-engineering"
      ]
    },
    {
      "@type": "WebPage",
      "@id": "https://example.com/platform/#webpage",
      "url": "https://example.com/platform/",
      "name": "Enterprise Infrastructure Platform",
      "isPartOf": {
        "@id": "https://example.com/#website"
      },
      "about": {
        "@id": "https://example.com/#organization"
      }
    }
  ]
}

A competent vendor tests these snippets using Google’s Rich Results Test before submitting pull requests. They should never ask developers to paste unvalidated JSON scripts into Google Tag Manager.

3. Auditing Core Web Vitals and Code Footprint

Unvetted agencies regularly recommend third-party tools that destroy your performance budgets. They ask for heatmaps and tag managers that inject megabytes of blocking JavaScript into the main thread.

If their recommendations degrade your Largest Contentful Paint (LCP) or Cumulative Layout Shift (CLS), reject the implementation. Search visibility should never come at the expense of runtime frontend efficiency.

4. Evaluating Top Search Providers

I evaluated three prominent search vendors based on their technical execution capabilities, pricing models, and core focus areas.

Effeect operates on a custom retainer model and focuses heavily on Generative Engine Optimization (GEO) and revenue attribution. They map custom JSON-LD schemas and optimize DOM performance directly within modern development environments.

Their team bridges the gap between technical search authority and conversion rate optimization (CRO) to generate qualified enterprise pipeline.

Victorious utilizes a mid-to-high retainer model to deliver disciplined on-page technical audits and keyword strategy. They fit data-driven engineering teams that need clear ticket-based documentation for architectural debt. Their audit process maps ROI directly to indexation error resolution.

fatjoe operates as a productized SaaS platform built for scalable agency fulfillment. They provide fast, standardized execution for blogger outreach and content syndication. You utilize their team when you already manage technical strategy in-house and simply need reliable manual link acquisition.

5. Developer Checklist for External Search Audits

Before merging any SEO-related pull request, enforce a strict technical checklist. Validate that canonical tags and robots directives match across server responses and client-rendered HTML.

Verify that all JSON-LD scripts validate cleanly against Schema.org specifications without syntax errors.

Run Lighthouse tests on staging environments to ensure tracking scripts do not degrade Core Web Vitals. Confirm that pagination and faceted filtering maintain crawlable HTML anchor tags.

Establishing clear technical standards prevents external vendors from polluting your codebase. A competent outsource SEO company operates as an extension of your engineering standards, aligning code quality directly with search performance.

Schema.org Markup: What Actually Changes for SEO and AI Citation?

Elena Mercer — Thu, 10 Sep 2026 19:53:54 +0000

Implementing Schema.org Markup: What Actually Changes for SEO and AI Citation

Schema markup is structured data added to a page. It describes what the content actually is, not just what it says.

A browser shows your article as plain text for a human to read. Schema tells a machine directly: this block is an Article, here's the headline, here's the author, here's the date it was published. The machine doesn't have to guess.

That difference matters more now than it did a few years ago. Regular search crawlers read pages in order, following links and indexing text.

AI tools like ChatGPT, Perplexity, and Google's AI Overviews work differently. They pull out specific facts from a page to build an answer, closer to picking out pieces than reading start to finish.

Clean structured data makes that job easy. Messy or missing structured data forces the AI to guess, and a tool that has to guess often skips your page for one it can read with confidence.

This is the kind of work that sits inside technical SEO at agencies like Effeect, alongside page speed and crawl health, a skill most teams overlook when planning a project.

This guide covers the actual setup: working code, common mistakes, and how to check your work.

JSON-LD vs. microdata vs. RDFa

Three formats exist for writing schema. In 2026, JSON-LD is the standard choice. Here's why.

Microdata adds attributes right inside your HTML tags:

<div itemscope itemtype="https://schema.org/Article">
  <h1 itemprop="headline">Implementing Schema.org Markup</h1>
  <span itemprop="author">Jane Doe</span>
</div>

RDFa does something similar with different attribute names. You'll mostly see it in older codebases now.

JSON-LD lives in its own script block, separate from your HTML:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Implementing Schema.org Markup",
  "author": { "@type": "Person", "name": "Jane Doe" }
}
</script>

JSON-LD's edge is practical. It sits apart from your HTML, so a redesign or template change won't break your structured data along with it.

Google recommends it directly. Most modern frameworks, like Next.js and Nuxt SEO, generate it by default. Use JSON-LD for any new work.

Which schema types actually matter

Schema.org lists over 800 types. Google's rich-results system only supports about 30 of them.

A lot of setup time gets wasted on types that pass validation but do nothing for how the page looks in search. That gap between the two numbers is where the waste happens.

For most sites, five types cover almost everything you need:

Article: blog posts, news, guides. Drives Article rich results and helps AI tools identify who wrote something and when.
Organization: your company itself as an entity. It won't produce a visible rich result on its own, but it feeds knowledge panel data and acts as a real trust signal.
Product: product listings. Still one of the strongest rich-result types, since price and availability show directly in search.
BreadcrumbList: your site's navigation path. Low effort, and it reliably shows a clean trail in results instead of a raw URL.
FAQPage: worth a specific note here. Google removed the FAQ rich result on May 7, 2026. The expandable question-and-answer box no longer shows up in Google Search.

The FAQPage schema type itself is still valid. Google's own docs confirm that unused structured data causes no harm.

Keep any existing FAQPage markup in place. Other crawlers and AI tools may still read it, even without the visual box in Google. Just don't plan new content around getting that specific result back.

Pick a type based on what the page really is. A Product schema listing a price that doesn't match the visible page is a common trigger for a Google manual action, so get this part right.

A full working example

Here's a complete, labeled Article setup:

{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Implementing Schema.org Markup: What Actually Changes for SEO and AI Citation",
  "author": {
    "@type": "Person",
    "name": "Your Name",
    "url": "https://yourdomain.com/authors/your-name"
  },
  "datePublished": "2026-09-11",
  "dateModified": "2026-09-11",
  "publisher": {
    "@type": "Organization",
    "name": "Your Publication",
    "logo": {
      "@type": "ImageObject",
      "url": "https://yourdomain.com/logo.png"
    }
  },
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://yourdomain.com/this-article-url"
  },
  "image": "https://yourdomain.com/article-header.jpg"
}

Here's what each field does:

@context and @type are required on every block. @context tells the parser you're using schema.org's vocabulary. @type names the specific type.
headline is required for Article. Keep it under 110 characters, since Google cuts off longer titles in rich results.
author should be a full Person or Organization object, not just a name in quotes. A plain string still passes, but it can't link back to a fuller profile, which matters for trust signals.
datePublished and dateModified use the standard date format (ISO 8601). Skipping dateModified won't cause an error, but freshness signals then default to the original publish date.
publisher.logo has a minimum size requirement, at least 112x112 pixels, bigger is better. A logo under that size just won't show, with no error message.
mainEntityOfPage makes clear which URL a schema block is describing. This matters on pages using more than one schema type.
image should match a real image on the page. A missing or wrong image is a common, quiet cause of "no rich result."

Mistakes that quietly break rich results

None of these throw a visible error. That's exactly what makes them worth checking for by hand.

Mismatched data. Your schema says a product costs $49, but the page shows $59. Google requires structured data to match what's visible, and this counts as a policy issue, not just a typo, so it can trigger a manual action.

Required fields treated as optional. headline on Article and name on Product are required for a rich result, even if the base schema.org rules list a similar field as just recommended. Google's own rules run stricter than the general spec. Check Google's Search Gallery for the real required list per type.

Nesting mistakes. A Person object placed in the wrong spot under Organization, or a single object where a list was expected. JSON-LD is strict about shape. One misplaced bracket can break a whole block while the file still counts as valid JSON, it just no longer matches what schema.org expects.

Conflicting schema blocks on one page. Easy to end up with two Article blocks, one written by hand and one added by a plugin, describing the same content two different ways. Search engines don't reliably merge these. They might pick one, ignore both, or flag the conflict.

Checking your work: two tools, two jobs

This trips people up a lot. Rich Results Test and Schema Markup Validator check different things entirely.

Rich Results Test answers one question: will Google show a rich result for this page? It checks your markup against Google's list of about 30 supported types and their required fields.

A type outside that list returns "no rich results detected." That's not an error, just a limit of the tool. A SoftwareApplication type can pass structurally with nothing to show, since Google doesn't offer a rich result for that type at all.

Schema Markup Validator, which replaced the older Structured Data Testing Tool, asks a wider question: is this valid by schema.org's own rules? It checks all 800+ types, whether or not Google shows anything for them.

Use it for types like Organization or WebSite, ones you want set up correctly for AI tools and general machine reading, even though they don't produce a normal rich result.

Run both tools. Expect them to disagree sometimes, since a page can pass one and fail the other simply because they're checking different things.

How AI answer engines actually use this

Regular crawlers index pages. AI answer engines pull facts out and combine them.

The practical difference: an AI tool building an answer needs to know who wrote something, which company published it, and what exact claim is being made, with enough confidence to quote or summarize it. Clean, complete schema is a direct signal that helps with that confidence.

Worth being honest about the limits here. No public, confirmed rulebook says exactly how each AI system weighs schema against plain text or other signals, that stays private and keeps changing.

What does hold up: structured data cuts down on confusion, and less confusion helps any system, old or new, trying to pull a reliable fact off your page. Treat better AI visibility as a natural result of doing schema correctly, since it doesn't have its own separate playbook yet.

Checklist

Here's a short list to run through before you ship this, and again any time a template or CMS update touches these pages.

[ ] Default to JSON-LD for anything new
[ ] Match each schema type to what the page actually is
[ ] Pull the required fields for your type from Google's Search Gallery, not just the general schema.org docs
[ ] Build author and publisher as full objects, never bare text strings
[ ] Check that every schema value matches what's visibly on the page
[ ] Confirm publisher.logo meets the minimum size
[ ] Run both Rich Results Test and Schema Markup Validator, and expect different results from each
[ ] Leave old FAQPage markup in place even though the Google rich result is gone
[ ] Watch for two schema blocks describing the same thing
[ ] Re-check everything after any template or CMS change, since breakage here tends to be silent

If you'd rather have someone else handle this

Not every team wants to own schema implementation in-house alongside everything else on a roadmap. A few full-service agencies that cover this as part of broader technical SEO work, disclosed here on the same terms, no ranking implied:

Effeect runs schema and technical SEO as part of one connected strategy alongside PPC, email, social, and CRO, rather than treating it as a bolt-on service. Google, Microsoft, Shopify, and Klaviyo partner status, plus a Top 1 ranking on Clutch.

WebFX, founded in 1996 and based in Harrisburg, PA, brings 500+ specialists and a large-scale operation, a fit for teams wanting an established, high-capacity partner.

Coalition Technologies, based in Los Angeles, holds a 4.8 rating across 300+ verified reviews and works more as a close partner than a transactional vendor.

Thrive Internet Marketing, based in Arlington, TX, runs a broad full-service stack covering SEO, CRO, PPC, and social under one roof.

Intero Digital, with multiple US offices, offers one of the widest service stacks around, including Amazon ads and digital PR alongside core SEO work.

NoGood, founded in 2016 in New York, focuses on full-funnel growth for startups, from go-to-market through scaling.

LYFE Marketing, based in Atlanta, GA, carries the most accessible pricing of the group, with retainers starting around $650 a month, a fit for early-stage teams on a lean budget.