How to Build a Scalable Headless CMS for Event Reporting: A Case Study Inspired by the 2025 Rosemont Coin Show

The future of content management? It’s already here—and it’s headless. I’ve spent months building a CMS that could handle the kind of rich, fast-paced reporting we saw at the 2025 Rosemont/Chicago Great American Coin Show. Not just another blog post. Think high-res photos, real-time dealer updates, and stories from collectors across the country. All while staying fast, secure, and easy to manage.

That’s where a headless CMS shines. I’ll show you how to build one—not in theory, but from real code, real decisions, and lessons learned from a live event report.

Why Headless CMS? What’s Wrong With the Old Way?

Old-school systems like WordPress were built for one thing: websites. But today, your content lives everywhere. Web. Mobile apps. Digital kiosks. Even smart displays in convention centers.

When everything—content, design, and code—is tangled together, it’s hard to scale. Hard to update. Hard to *move fast*.

A headless CMS cuts that knot. It’s just a content hub. No templates. No front-end. Just clean, structured data served through APIs.

That means:

• Publish once, show everywhere—web, app, newsletter, social
• Pages load faster (we’re talking sub-second for image-heavy galleries)
• Your backend stays locked down—no public access, fewer attack vectors
• Pick your tools. React? Vue? Svelte? Go wild.

For an event like Rosemont—where you’re publishing 50+ photos, multiple dealer spotlights, and live updates—this setup keeps things smooth. No lag. No crashes. No “wait, why isn’t this image loading?”

My Stack: Simple, Fast, and Built to Last

Here’s the combo I trust for real projects:

• Headless CMS: Strapi, Sanity.io, or Contentful
• Static Site Generator: Next.js (or Gatsby for smaller sites)
• Hosting & CDN: Vercel or Netlify

This is the Jamstack—not a buzzword. It’s how modern sites work: pre-build pages, cache them globally, and serve them instantly. No database queries on every click.

Which Headless CMS Should You Pick?

I’ve used all three. Each has its sweet spot—especially for a content-heavy event like a coin show with multiple authors, rich media, and structured data.

1. Strapi: Full Control, Your Way

Self-hosted. Open-source. Built on Node.js. Strapi gives you total ownership of your data and code.

Good fit if: You have a dev team. Need to tweak the admin panel. Or want to add custom features—like a dealer search tool or a private API for partners.

Real example: Modeling a coin show

module.exports = {
  collectionName: 'coin_shows',
  attributes: {
    title: { type: 'string' },
    date: { type: 'date' },
    location: { type: 'string' },
    dealers: { 
      collection: 'dealer',
      via: 'show'
    },
    photos: { 
      collection: 'file',
      via: 'related',
      plugin: 'upload'
    },
    attendees: { type: 'json' } // For quick access to names, roles, bios
  }
};

With Strapi, I built a model that matches the Rosemont event: shows, dealers, photos, and even wine pairings (yes, the Rombauer Zinfandel got its own field—it was that good).

2. Sanity.io: Real-Time Editing, No Waiting

Sanity’s not just a CMS. It’s a collaborative studio. Multiple editors can work at once. Content updates in real time. And its query language—GROQ—is perfect for complex content.

Good fit if: Your team includes non-devs. You edit content daily. Or you need nested relationships (like “show this dealer’s best coin”).

Real example: Pulling structured event data

{
  "show": *[_type == "coinShow" && date > "2025-01-01"][0]{
    title,
    date,
    location,
    "dealers": dealers[]->{
      name,
      company,
      "photo": photo.asset->url
    },
    "photos": photos[].asset->url
  }
}

Sanity made it easy to pull just the data we needed—no extra fluff. That’s crucial when you’re loading 100+ images and want to keep things snappy.

3. Contentful: Built for Big Teams and Big Traffic

Used by the pros. Contentful handles high traffic, global teams, and complex workflows. Think editorial reviews, localization, and compliance.

Good fit if: You’re in a large org. Need audit trails. Or expect thousands of visitors during the event.

Pro tip: Use the Content Delivery API with field filtering. For a gallery, only grab image URLs and captions. Load full details on click. Cuts payload size in half.

Building the Frontend: Fast, Smart, and SEO-Ready

A great CMS is only half the battle. The frontend has to deliver. That means speed, SEO, and a smooth experience—even on crowded Wi-Fi at the convention center.

Next.js: The Smart Default

I reach for Next.js first. It does static generation, dynamic updates, and API routes—all in one.

• Static Generation (SSG): Build pages ahead of time
• Incremental Static Regeneration (ISR): Update pages in the background—no full rebuild
• API Routes: Handle form submissions, webhooks, or email alerts

Real example: A coin show gallery that stays fresh

export async function getStaticProps() {
  const res = await fetch('https://api.sanity.io/...');
  const data = await res.json();
  return {
    props: { data },
    revalidate: 3600 // Update every hour
  };
}

export default function Gallery({ data }) {
  return (
    

      {data.photos.map(photo => (
        
      ))}
    
  );
}

Pages load instantly. But if a new photo drops, the site updates in the background. No downtime. No manual rebuilds.

Gatsby: When Every Millisecond Counts

Gatsby is great for smaller, content-heavy sites. Its image plugins work magic—automatically compressing, resizing, and lazy-loading photos.

Pro tip: Add gatsby-plugin-offline. Lets users read the report even when the network drops—perfect for roaming the bourse floor.

Content That Works Everywhere: Structure It Right

Most teams treat event reports like one-off pages. But smart ones model them as reusable objects. That way, the same content can power:

• The full event page
• Dealer spotlight cards
• Photo carousels
• Newsletter snippets
• Mobile app feeds

How I Modeled the 2025 Rosemont Show

Here’s the content model I built—based on what actually happened at the show:

{
  "show": {
    "title": "2025 Rosemont/Chicago Great American Coin Show",
    "date": "2025-09-30",
    "location": "Rosemont Horizon, Chicago",
    "dealers": [
      {
        "name": "Chad Stachowicz",
        "company": "Stachowicz Coins",
        "specialties": ["Indian cents", "Lincoln cents"],
        "photo": "https://...",
        "showMentions": ["purchased 1914-D Lincoln cent"]
      }
    ],
    "attendees": [
      {
        "name": "Rick Snow",
        "role": "Dealer",
        "status": "Recovered from health issue",
        "photo": "https://..."
      }
    ],
    "photos": [
      {
        "url": "https://...",
        "caption": "Bourse floor setup",
        "credit": "Charmy",
        "type": "wide" // For layout decisions
      }
    ],
    "vendors": [
      {
        "name": "PCGS",
        "boothPhotos": ["https://..."]
      }
    ],
    "relatedEvents": [
      {
        "name": "2026 Rosemont Show",
        "date": "2026-09-30",
        "link": "/events/2026-rosemont"
      }
    ]
  }
}

This structure lets us:

• Filter dealers by specialty (“Show me all Lincoln cent experts”)
• Personalize content (“Photos from your favorite dealer”)
• Link to future events—no manual updates

Make It Fast: From CMS to CDN

Speed isn’t a nice-to-have. It’s required. For a site with 100+ photos, every second matters.

Here’s what I did:

1. Optimize Images

Use modern formats (WebP, AVIF) and responsive sizes:

// Next.js Image component

Result? Images load fast. Look great. And don’t break the bank on bandwidth.

2. Cache Everything

Set CDN headers for static files:

Cache-Control: public, max-age=31536000, immutable

That means browsers keep files for a year. No repeat downloads.

3. Lazy Load the Heavy Stuff

Don’t load videos or social embeds until the user scrolls near them. Saves data. Keeps the initial load light.

Final Thoughts: This Isn’t Just About Coin Shows

The 2025 Rosemont report was a test. Could we build a CMS that’s fast, flexible, and ready for anything?

Answer: Yes. And it works for any event—sports, conferences, festivals. Even wine tastings (yes, the Zinfandel had its own API).

By using a headless CMS (Strapi, Sanity, or Contentful), a Jamstack approach, and a static site generator (Next.js or Gatsby), you get:

• Pages that load in under a second
• Content that ranks well on Google
• Models that work across every channel
• Infrastructure that scales—no matter the traffic

For developers, this means freedom. Want to add AR coin previews? A live dealer map? A blockchain validator? You can. The CMS doesn’t care.

For teams, it means less hassle. Faster publishing. Fewer crashes. Happier users.

So build something real. Something fast. And if you’re at the 2026 show, look for the guy with the laptop—and the glass of Zinfandel. I’ll be there. Testing version two.

Related Resources

You might also find these related articles helpful:

• How Coin Show Market Dynamics Can Inspire Smarter High-Frequency Trading Algorithms – Uncovering Hidden Patterns in Illiquid Markets: A Quant’s Take on Coin Shows High-frequency trading (HFT) thrives …
• How to Turn a Coin Show Report Into a Powerful Business Intelligence Asset Using Data Analytics – Ever left a coin show with a stack of notes, photos, and receipts—only to file it away and forget about it? That’s a mis…
• How I Cut CI/CD Pipeline Costs By 30% Using Practical DevOps Strategies – I used to dread our CI/CD pipeline. It felt like a money pit — slow builds, random deployment failures, and compute cost…