Building a Headless CMS for Event-Driven Platforms: A CMS Developer’s Case Study on High-Scale Show Management

The future of content management is headless. Let me walk you through how I built a fast, flexible CMS for event platforms—using real lessons from our recent PCGS show migration.

Why Headless CMS? The Shift from Monolithic to API-First

Traditional platforms like WordPress work fine for brochure sites. But show management? That’s a different beast.

At PCGS, we needed to coordinate:

• Web and mobile updates
• Real-time parking validation
• Vendor communications
• Last-minute schedule changes

A headless CMS gave us what we needed: complete separation between our content (the “body”) and presentation (the “head”). This simple change unlocked:

• Freedom to use React, Vue, or any frontend tool
• Lightning-fast Jamstack delivery
• Easy connections to ticketing and mapping APIs
• Flexible content types for shows, vendors, and pricing
• One source of truth for all digital touchpoints

Our case study? Moving the Long Beach coin show to the new PCGS Irvine CA Show (Oct 22-24, 2025). No room for error. Zero downtime required.

Choosing the Right Headless CMS: Contentful vs. Strapi vs. Sanity.io

Each option has strengths. Here’s what worked (and didn’t) for our team:

1. Contentful: Enterprise Muscle

Perfect for structured content at scale. We loved the built-in tools for global events.

• What worked: Localization, webhooks, GraphQL API
• Trade-off: Can get pricey at high traffic; some field limitations

For the Irvine show, we created a ShowEvent type with dates, location, vendors, and access levels. The Content Delivery API fed data to our Next.js app with incremental static regeneration.

// Fetch show details with ISR (Next.js)
export async function getStaticProps() {
  const res = await fetch(
    `https://cdn.contentful.com/spaces/${space}/entries?access_token=${token}&content_type=showEvent&fields.id=Irvine2025`
  );
  const data = await res.json();
  return { props: { data }, revalidate: 3600 };
}

2. Strapi: Total Control

When you need to own your infrastructure, Strapi shines. Essential for keeping PCGS attendee data private.

• What worked: Open-source, self-hosted, custom plugins
• Trade-off: Needs DevOps support; scaling isn’t automatic

We used Dynamic Zones to build flexible blocks for FAQs and parking updates. The $15-$55 rate table became a reusable component we could update in minutes.

// Strapi content model for 'ParkingInfo'
{
  "collectionName": "parking_infos",
  "info": { "name": "Parking Info" },
  "attributes": {
    "type": { "type": "enumeration", "enum": ["valet", "on-site", "free-mall"] },
    "rate": { "type": "decimal" },
    "validation": { "type": "text" },
    "location": { "type": "string" }
  }
}

3. Sanity.io: Real-Time Magic

Sanity’s Real-Time Studio saved our team countless hours. Ticket limit changes? Table count updates? Visible instantly everywhere.

• What worked: Live previews, custom inputs, strong GraphQL
• Trade-off: Steeper learning curve; fewer templates

We built a custom drag-and-drop interface for the ShowSchedule field. Organizers could move sessions around and get conflict warnings in real time.

Jamstack Architecture: Next.js, Gatsby, and Static Site Generators

With our CMS ready, we went full Jamstack. No PHP servers. No database queries during visits. Just pre-built pages and smart updates.

Next.js: Best of Both Worlds

For the main show site, Next.js gave us static speed with dynamic flexibility. ISR meant pages built at deploy time but refreshed in the background every 5 minutes.

// Next.js page with ISR
export async function getStaticPaths() {
  return { paths: [{ params: { id: 'Irvine2025' } }], fallback: 'blocking' };
}

export async function getStaticProps({ params }) {
  const data = await fetchShowFromCMS(params.id);
  return { props: { data }, revalidate: 300 }; // Update every 5 min
}

Gatsby: Static Perfection

For marketing pages like “About PCGS” and “Why Attend,” Gatsby delivered:

• Pages that work without JavaScript
• Built-in image optimization

We pulled CMS data through Gatsby’s Source Nodes. In 25 seconds, we generated over 100 pages—ready for launch.

// Gatsby source CMS nodes
exports.sourceNodes = async ({ actions }) => {
  const { createNode } = actions;
  const shows = await fetchCMS('/shows');
  shows.forEach(show => {
    createNode({
      ...show,
      internal: { type: 'ShowEvent' },
    });
  });
};

API-First Content: Building for Flexibility

Headless shines when you treat content as data. Every show date, parking rate, and vendor name lived in our APIs—ready for any device or service.

Real Example: Parking Validation

Attendees needed instant parking validation. Our solution:

1. Pull latest rates from CMS
2. Check ticket status with PCGS API
3. Email QR code for valet access

// Lambda: validateParking.js
exports.handler = async (event) => {
  const { ticketId } = JSON.parse(event.body);
  const parkingData = await fetchCMS('/parking?validated=true');
  const isValid = await pcgsApi.validateTicket(ticketId);
  if (isValid) {
    await sendQRCode(ticketId);
    return { statusCode: 200, body: JSON.stringify(parkingData) };
  }
  return { statusCode: 403, body: 'Invalid ticket' };
};

One Content Source, Many Uses

Our CMS data powered:

• Email campaigns (SendGrid integration)
• Mobile apps (React Native)
• Venue kiosks (web views)
• Chatbots (Dialogflow webhooks)

Actionable Takeaways

Lessons from our journey you can use today:

• Map your content first Shows, vendors, tickets—get these relationships clear before picking a CMS
• Static sites can be dynamic ISR gives you fast pages that update in the background
• Build APIs for everything Make content accessible to web, mobile, IoT, and AR
• Real-time matters For live events, webhooks and live previews keep teams aligned
• Mobile is critical Over 60% of our traffic came from phones; responsive design is non-negotiable

Conclusion: The Headless Advantage for Event Platforms

The PCGS Irvine show wasn’t just a technology project. It was about people:

• Attendees got fast, reliable information
• Organizers updated content without calling IT
• Our team connected workflows without custom code

The formula for modern event platforms? Headless CMS + Jamstack + API-first design. You get speed, flexibility, and scalability—without the headaches of old-school CMS platforms.

When the Long Beach era ends, the new shows will run on this architecture. And as a CMS developer? That’s exactly where I want to be—helping teams build better experiences, one show at a time.

Related Resources

You might also find these related articles helpful:

• Lessons from Long Beach to Irvine: Building a Smarter MarTech Stack for Event-Driven Marketing – The MarTech world moves fast. But here’s what I’ve learned after years building tools for event marketers – …
• How Real Estate Tech Innovators Can Leverage Event-Driven Data and Smart Venues to Transform PropTech – The real estate industry is changing fast. Let’s talk about how today’s tech—especially event-driven data an…
• How Coin Show Market Dynamics Can Inspire Smarter High-Frequency Trading Algorithms – In high-frequency trading, every millisecond matters. I started wondering: Could the fast-paced world of coin shows teac…