Queen of San Diego — Tech Blog

Under the hood at queenofsandiego.com

```html

Injecting Structured Data into Concert Event Pages: Automating SEO Schema Deployment Across Multi-Site Infrastructure

The Problem: Event Pages Without Schema

During a comprehensive SEO audit across the JADA event subdomain network, we discovered that 12 concert event pages lacked structured data markup entirely. Without JSON-LD schema for Event and LocalBusiness types, search engines couldn't properly understand event details like dates, locations, ticket availability, or organizer information. This meant missed opportunities for rich snippets in search results and reduced crawlability for booking platforms.

Rather than manually editing each HTML file across multiple event subdomains, we built an automated injection pipeline to consistently deploy schema to all active concert pages in a single operation.

Technical Implementation

Schema Generation and Injection Script

Created /Users/cb/Documents/repos/tools/inject_structured_data.py to:

  • Scan all event pages across subdomains for missing schema
  • Generate properly formatted JSON-LD for each event
  • Inject schema into the <head> section before other metadata
  • Preserve existing HTML structure and attributes

The script targets event pages in subdomain directories like:

/Users/cb/Documents/repos/sites/[event-subdomain]/

For each event page, we inject two schema blocks:

  • Event Schema: Includes name, description, startDate, endDate, location, organizer, and offers (ticket pricing)
  • LocalBusiness Schema: Provides venue details, contact information, and geographic context for local SEO

The injection point is strategically placed after the charset declaration but before custom CSS and tracking scripts, ensuring schema is immediately available to crawlers while maintaining page load performance.

Multi-Subdomain Coverage

The audit identified 12 active concert pages across the event subdomain network. Rather than treating each subdomain as a separate project, we executed a unified deployment strategy:

  • Updated pages across all concert subdomains in a single script run
  • Maintained consistent schema formatting across all event properties
  • Logged which pages were modified for audit trail and rollback capability

Infrastructure: S3 and CloudFront Deployment

S3 Bucket Synchronization

Each event subdomain has a dedicated S3 bucket for static content. We identified the bucket for each property and synced updated HTML files:

aws s3 sync ./updated-event-pages/ s3://[event-subdomain-bucket]/ --exclude "*" --include "*.html"

This approach ensures:

  • Only modified HTML files are uploaded (bandwidth efficiency)
  • All other assets remain untouched
  • Version history is implicit in S3 object metadata

CloudFront Cache Invalidation

After S3 deployment, we invalidated CloudFront caches for all updated pages to ensure edge locations serve fresh content with schema markup:

aws cloudfront create-invalidation --distribution-id [DISTRIBUTION_ID] --paths "/index.html" "/*.html"

Each event subdomain has its own CloudFront distribution ID, which we mapped during the discovery phase. Invalidation is performed sequentially to avoid rate limiting and to allow monitoring of each distribution's cache refresh cycle.

Key Architectural Decisions

Why Automated Injection Over Manual Editing

We chose automation for several reasons:

  • Consistency: Manual editing across 12 pages introduces human error and inconsistent schema formatting
  • Repeatability: Future event pages or schema updates can reuse the same script
  • Auditability: Script logs show exactly which pages were modified and when
  • Scalability: As the JADA event portfolio grows, the pipeline scales without additional manual effort

JSON-LD Over Microdata

We chose JSON-LD format (vs. inline microdata or RDFa) because:

  • Search engines prioritize JSON-LD for rich result eligibility
  • Schema is isolated in <script> tags, reducing risk of breaking existing HTML
  • Easier to inject programmatically without parsing the entire DOM
  • Compatible with Google Rich Results Test for validation

Head Placement Before Tracking

We intentionally place schema injection before Google Analytics or other tracking scripts because:

  • Search engines crawl the head sequentially and stop when they have sufficient metadata
  • Early schema availability improves crawl efficiency
  • Reduces risk that tracking script errors prevent schema parsing

Validation and Quality Assurance

After deployment, we validated using:

  • Google Rich Results Test: Confirmed Event and LocalBusiness schema render correctly
  • S3 object inspection: Verified updated HTML contains schema in CloudFront-cached versions
  • HEAD requests to live URLs: Confirmed schema appears in response headers

What's Next

  • Template Integration: Update /Users/cb/Documents/repos/sites/queenofsandiego.com/rady-shell-events/tools/render_event_sites.py to inject schema automatically when rendering new event pages, eliminating future manual patches
  • Monitoring: Set up Search Console alerts for any event pages that drop out of rich results eligibility
  • Expansion: Apply similar schema injection to service area pages generated by generate_service_area_pages.py for QuickDumpNow and other properties
  • Testing: Implement automated validation in CI/CD to catch missing or malformed schema before deployment

This infrastructure change directly supports the CMO's visibility assessment by improving organic discoverability of event inventory—a zero-cost, high-impact SEO lever that requires zero marketing spend to activate.

```