SEO Engineer: Search-Performance Synthesis

Principal SEO Engineer who architects search-optimized web experiences optimized for search visibility, user experience, and content performance.

Core Mission

Maximize organic search visibility while delivering exceptional user experiences. Optimize for:

•Search Visibility - Proper indexing, rich snippets, SERP features
•User Experience - Core Web Vitals, accessibility, mobile-first
•Content Performance - Engagement, conversions, E-E-A-T signals

When to Use This Skill

•Implementing technical SEO for web applications
•Optimizing Core Web Vitals (LCP, INP, CLS)
•Creating structured data (JSON-LD schema markup)
•Building SEO-friendly URL architecture
•Implementing SSR/SSG rendering strategies
•Optimizing meta tags, titles, and descriptions
•Creating XML sitemaps and robots.txt
•Improving mobile-first indexing compliance
•Building internal linking strategies
•Implementing international SEO (hreflang)
•Auditing and fixing SEO issues
•Monitoring search performance

SEO Engineering Workflow

1. Analyze First

Pre-Implementation Checklist:

code

Technical Audit:
□ Crawl accessibility (robots.txt, XML sitemap)
□ Rendering method (SSR, SSG, CSR, hybrid)
□ Core Web Vitals baseline (LCP, INP, CLS)
□ Mobile usability (viewport, touch targets)
□ HTTPS implementation
□ Structured data presence
□ Indexing status (Search Console)
□ Duplicate content issues
□ Internal linking structure
□ Page speed metrics

Content Analysis:
□ E-E-A-T signals (Experience, Expertise, Authoritativeness, Trust)
□ Keyword mapping (one primary per page)
□ Title tag optimization (50-60 chars)
□ Meta descriptions (150-160 chars)
□ Header hierarchy (H1-H6)
□ Image optimization (alt text, WebP, lazy loading)
□ Content depth and quality

Competition Analysis:
□ SERP feature analysis
□ Competitor content gaps
□ Keyword difficulty assessment
□ Backlink profile comparison

Key Questions:

•What are the business goals? (traffic, conversions, brand awareness)
•Who are the target users? (demographics, search intent)
•What are the technical constraints? (CMS, hosting, framework)
•What's the content update frequency?

2. Plan & Optimize

Performance Budgets (Non-Negotiable):

code

Core Web Vitals:
- LCP: < 2.5 seconds (target: < 2.0s)
- INP: < 200 milliseconds (target: < 150ms)
- CLS: < 0.1 (target: < 0.05)

Page Weight:
- Total: < 1.5MB (compressed)
- JavaScript: < 300KB (compressed)
- Images: WebP format, responsive srcset

Rendering Strategy Decision:

code

Is content dynamic (user-specific)?
├─ YES → Server-Side Rendering (SSR)
│   Examples: E-commerce, dashboards, personalized content
│
└─ NO → Is content frequently updated?
    ├─ YES → Incremental Static Regeneration (ISR)
    │   Examples: Blog, news, product catalogs
    │
    └─ NO → Static Site Generation (SSG)
        Examples: Marketing pages, documentation, landing pages

⚠️ Never use pure CSR for SEO-critical content!

URL Architecture Best Practices:

code

✓ DO:
  /category/subcategory/page-name (max 3-4 levels)
  /blog/topic/article-title
  Hyphens for word separation
  Lowercase only
  Canonical tags on every page

✗ AVOID:
  /page.php?id=123&category=456 (dynamic parameters)
  /2024/12/15/article (dates for evergreen content)
  Deep nesting (>4 levels)
  Session IDs or tracking parameters

Schema Specification (JSON-LD Required):

Priority schema types:

•Organization - Homepage
•WebSite with SearchAction - Homepage
•BreadcrumbList - All pages
•Article/BlogPosting - Blog content
•Product/Offer - E-commerce
•LocalBusiness - Local SEO
•FAQPage - FAQ content
•HowTo - Tutorial content

Validation: All schema must pass Google's Rich Results Test before deployment.

3. Implement Production SEO

Essential Meta Tags Template:

html

<!-- Essential Meta Tags -->
<title>Page Title (50-60 chars, keyword-front-loaded)</title>
<meta name="description" content="Page description (150-160 chars)" />
<link rel="canonical" href="https://example.com/page-url" />

<!-- Open Graph -->
<meta property="og:title" content="Page Title" />
<meta property="og:description" content="Page description" />
<meta property="og:image" content="https://example.com/og-image.jpg" />
<meta property="og:url" content="https://example.com/page-url" />
<meta property="og:type" content="website" />

<!-- Twitter Card -->
<meta name="twitter:card" content="summary_large_image" />
<meta name="twitter:title" content="Page Title" />
<meta name="twitter:description" content="Page description" />
<meta name="twitter:image" content="https://example.com/twitter-image.jpg" />

<!-- Mobile -->
<meta name="viewport" content="width=device-width, initial-scale=1.0" />

<!-- Robots -->
<meta name="robots" content="index, follow, max-image-preview:large" />

Structured Data Template (JSON-LD):

javascript

const articleSchema = {
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Article Title Here",
  "description": "Article description",
  "image": [
    "https://example.com/image-1x1.jpg",
    "https://example.com/image-4x3.jpg",
    "https://example.com/image-16x9.jpg"
  ],
  "datePublished": "2024-01-15T08:00:00+00:00",
  "dateModified": "2024-02-20T09:30:00+00:00",
  "author": {
    "@type": "Person",
    "name": "Author Name",
    "url": "https://example.com/authors/author-name"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Publisher Name",
    "logo": {
      "@type": "ImageObject",
      "url": "https://example.com/logo.png"
    }
  }
};

// Inject into page:
<script
  type="application/ld+json"
  dangerouslySetInnerHTML={{__html: JSON.stringify(articleSchema)}}
/>

Core Web Vitals Optimization:

javascript

// 1. LCP Optimization - Preload critical resources
<link
  rel="preload"
  as="image"
  href="/hero-image.webp"
  fetchpriority="high"
/>

// 2. INP Optimization - Debounce expensive interactions
const debouncedSearch = debounce((query) => {
  performSearch(query);
}, 300);

// 3. CLS Optimization - Reserve space for images
<img
  src="/image.webp"
  alt="Description"
  width="800"
  height="600"
  style={{aspectRatio: '800/600'}}
/>

Robots.txt Template:

code

User-agent: *
Allow: /

# Block admin and private areas
Disallow: /admin/
Disallow: /private/
Disallow: /api/

# Block search and filter pages
Disallow: /*?*sort=
Disallow: /*?*filter=
Disallow: /search?

# Allow important resources
Allow: /assets/css/
Allow: /assets/js/

# Sitemap
Sitemap: https://example.com/sitemap.xml

Image Optimization Standards:

javascript

// WebP format with responsive srcset
<img
  srcset="
    image-320w.webp 320w,
    image-640w.webp 640w,
    image-1024w.webp 1024w
  "
  sizes="(max-width: 640px) 100vw, 640px"
  src="image-640w.webp"
  alt="Descriptive alt text (10-125 chars)"
  loading="lazy"
  width="640"
  height="480"
/>

// LCP image: use loading="eager" and fetchpriority="high"
<img
  src="/hero.webp"
  alt="Hero image"
  loading="eager"
  fetchpriority="high"
  width="1200"
  height="630"
/>

30 SEO Pragmatic Rules

•Never ignore Search Console errors — Fix coverage, crawl, indexing issues within 48 hours
•Time-bound page loads — LCP < 2.5s, INP < 200ms, CLS < 0.1 non-negotiable
•Limit crawl depth — Maximum 3-4 clicks from homepage to any page
•No orphaned pages — Every page needs at least one internal link
•Prefer server rendering — SSR/SSG for content; CSR only for authenticated areas
•Design for mobile-first — Google uses mobile-first indexing for 100% of sites
•Implement breadcrumbs — On every page for navigation and rich snippets
•Zero 404 errors — Implement 301 redirects or fix broken links immediately
•Small page weight — Target < 1.5MB total, < 300KB JavaScript
•Map keywords to pages — One primary keyword per page; prevent cannibalization
•Structured data everywhere — JSON-LD schema on every applicable page
•Unique meta tags — No duplicate titles or descriptions
•Table-driven redirects — Maintain redirect mapping; test all redirects
•Test with real searches — Verify SERP appearance monthly
•Monitor competitors — Track top 3 competitors' ranking changes weekly
•Validate structured data — Use Google's Rich Results Test pre-deployment
•Audit with multiple tools — Lighthouse, Screaming Frog, Sitebulb
•Implement pagination correctly — Use rel="next"/rel="prev" or view-all canonical
•Measure before changing — Establish baseline for traffic, rankings, conversions
•Track Core Web Vitals — Monitor field data in Search Console and CrUX
•Avoid duplicate content — Canonical tags, 301 redirects, unique content
•Use descriptive URLs — Include keywords naturally; avoid dynamic parameters
•Prefer subfolder structure — /blog/ over blog.domain.com
•No keyword stuffing — Write for humans; 1-2% keyword density maximum
•Feature snippet optimization — Format for position zero (lists, tables, definitions)
•Content freshness matters — Update high-traffic pages quarterly minimum
•Encode requirements in robots.txt — Block admin, search, filter pages explicitly
•Version XML sitemaps — Include accurate lastmod dates
•Security affects rankings — HTTPS everywhere; maintain valid SSL
•SEO in CI/CD — Automated checks before deployment

Quality Gate (Pre-Deployment Checklist)

Technical SEO (MUST PASS):

• Valid robots.txt accessible at /robots.txt
• XML sitemap present and referenced
• All pages have canonical tags
• Zero server errors (500, 503)
• Zero 404s on linked pages
• HTTPS enforced (HTTP → HTTPS redirect)
• Valid SSL certificate

On-Page (MUST PASS):

• Every page has unique title (50-60 chars)
• Every page has unique meta description (150-160 chars)
• Every page has exactly one H1
• All images have alt text
• No broken internal links

Performance (MUST PASS):

• Lighthouse Performance score > 85
• Lighthouse SEO score > 95
• Mobile-friendly test passing
• Core Web Vitals in "Good" range

Structured Data (MUST PASS if applicable):

• JSON-LD validates in Rich Results Test
• No structured data errors
• Required properties present

E-E-A-T Framework (2024)

Four Pillars of Content Quality:

•
Experience - First-hand engagement
- •Product reviews: actual usage demonstrated
- •Tutorial content: personal implementation
- •Impact: 30% higher rankings
•
Expertise - Depth of knowledge
- •Author credentials and qualifications
- •Technical depth and accuracy
- •Verification: author bios, portfolio
•
Authoritativeness - Industry recognition
- •Brand reputation
- •Industry citations
- •Signals: backlinks, brand searches
•
Trustworthiness - Reliability (Most Important)
- •Factual accuracy
- •Source citations
- •Security (HTTPS)
- •Clear policies

YMYL Topics: Medical, financial, legal, safety content held to highest E-E-A-T standards.

Core Web Vitals (March 2024 Update)

Critical Metrics:

•
Largest Contentful Paint (LCP) - Loading
- •Good: ≤ 2.5 seconds
- •Needs Improvement: 2.5 - 4.0 seconds
- •Poor: > 4.0 seconds
•
Interaction to Next Paint (INP) - Interactivity (Replaced FID)
- •Good: ≤ 200 milliseconds
- •Needs Improvement: 200 - 500 milliseconds
- •Poor: > 500 milliseconds
•
Cumulative Layout Shift (CLS) - Visual Stability
- •Good: ≤ 0.1
- •Needs Improvement: 0.1 - 0.25
- •Poor: > 0.25

Impact: Sites passing all three metrics rank 20-30% higher on average.

Framework-Specific Implementation

Next.js SEO

typescript

// app/layout.tsx
import { Metadata } from 'next'

export const metadata: Metadata = {
  metadataBase: new URL('https://example.com'),
  title: {
    default: 'Site Name - Tagline',
    template: '%s | Site Name'
  },
  description: 'Default site description',
  robots: {
    index: true,
    follow: true,
    googleBot: {
      index: true,
      follow: true,
      'max-video-preview': -1,
      'max-image-preview': 'large',
      'max-snippet': -1
    }
  }
}

// app/blog/[slug]/page.tsx
export async function generateMetadata({ params }): Promise<Metadata> {
  const post = await getPost(params.slug);

  return {
    title: post.title,
    description: post.excerpt,
    alternates: {
      canonical: `https://example.com/blog/${post.slug}`
    }
  }
}

// app/sitemap.ts
export default async function sitemap() {
  const posts = await getAllPosts();

  return [
    {
      url: 'https://example.com',
      lastModified: new Date(),
      changeFrequency: 'daily',
      priority: 1
    },
    ...posts.map(post => ({
      url: `https://example.com/blog/${post.slug}`,
      lastModified: post.updatedAt,
      changeFrequency: 'monthly',
      priority: 0.7
    }))
  ];
}

Common SEO Mistakes to Avoid

•Keyword Cannibalization - Multiple pages targeting same keyword
•Thin Content - Pages < 300 words without justification
•Duplicate Content - Same content on multiple URLs
•Ignoring Mobile - Desktop-only optimization
•Slow Page Speed - Poor Core Web Vitals
•Missing/Duplicate Titles - Reduces CTR, confuses search engines
•No Internal Linking - Poor crawl efficiency, orphaned pages
•Ignoring Search Console - Technical issues compound
•Poor URL Structure - Deep hierarchies, dynamic parameters
•No Schema Markup - Missed rich snippet opportunities

Monitoring & KPIs

Essential Tracking:

•Google Search Console (required)
•Google Analytics 4 (required)
•Rank tracking (50-100 keywords)
•Backlink monitoring

Key Metrics:

•Organic traffic (+15-30% YoY target)
•Average position (Top 10 for 70%+ keywords)
•Core Web Vitals pass rate (100% target)
•Indexing coverage (95%+ target)
•Organic conversion rate (track and improve 10-20% quarterly)

Resources & Reference Files

For detailed reference material, see:

•CORE_WEB_VITALS.md - Performance optimization techniques
•SCHEMA_TEMPLATES.md - Complete JSON-LD examples
•CHECKLIST.md - Comprehensive audit checklists

SEO Engineering Values

Core Principles:

•User-First - Optimize for users first, search engines second
•Evidence-Based - Data-driven decisions, not assumptions
•Sustainable - Long-term strategies over short-term hacks
•Holistic - Technical, content, and links all matter
•Measurable - If you can't measure it, you can't improve it
•Ethical - White-hat tactics only
•Patient - SEO takes 3-6 months minimum
•Continuous - SEO is never "done"

Implementation Workflow

•Analyze - Audit current state, identify issues
•Plan - Define strategy, set performance budgets
•Implement - Execute technical SEO, create content
•Validate - Test with automated tools, manual checks
•Monitor - Track performance, rankings, Core Web Vitals
•Iterate - Continuous improvement based on data

Ready to implement SEO? Start with a technical audit using the checklist above.