When OpenAI announced their new Apps platform last week, I had one question: could I actually build something useful with it? I had an hour during a workout to find out.

The Experiment

It was early morning in my basement gym. Between sets, I pointed OpenCode at the ChatGPT docs and started prompting with Grok. The goal: integrate my family calendar system—the one that pulls events from TeamSnap, GameChanger, and other platforms—directly into ChatGPT.

"What events are happening next week?"
"Search for birthday events."
"Show me soccer games this month."

Could I build this in an hour while working out? Turns out, yes.

How ChatGPT Apps Work

The new Apps platform uses something called the Model Context Protocol (MCP). Think of it like this: you build a server that exposes "tools" ChatGPT can use, and ChatGPT decides when to call them based on the conversation.

My calendar app provides a calendar_search tool that:

  • Accepts optional keyword queries and date ranges
  • Fetches live data from my public ICS calendar feed
  • Returns structured event data (date, time, location, description)
  • Renders beautiful event cards in ChatGPT's UI

The Tech Stack

I let OpenCode and Grok handle the heavy lifting:

  • OpenCode + Grok - AI-powered development assistant that did most of the code generation
  • Node.js + Express - MCP server implementation
  • React 18 + TypeScript - Event card UI components
  • esbuild - Fast React bundling
  • ngrok - Local development tunnel (more on this in a moment)

The React component is theme-aware, switching automatically between ChatGPT's light and dark modes. It supports both list and grid views, and the calendar data is cached for 5 minutes to avoid hammering the feed.

The Security Team Story

Here's where it got interesting. I was testing this from my personal laptop in my basement, running ngrok to expose my local dev server to the internet. Later at work, I got a message from our security team—they'd spotted the ngrok tunnel from my personal laptop.

This is exactly the kind of thing that should raise flags in an enterprise environment—tunneling tools like ngrok can bypass network security controls and create unmonitored pathways. For a quick POC on a personal project? Totally fine. For production development? Absolutely a concern worth investigating. Good catch by the security team.

Building the Calendar Integration

The heart of the app is a straightforward ICS parser. My calendar feed already aggregates 1,200+ events from multiple sources into a single .ics file, so the MCP server just needs to:

  1. Fetch the feed (with 5-minute caching)
  2. Parse the ICS format into structured events
  3. Filter by keyword and date range if provided
  4. Return the results to ChatGPT

ChatGPT handles the natural language understanding—figuring out when the user wants to search, what keywords to use, and what date range makes sense. My server just provides the data.

The React Component

One of the cooler parts of the Apps SDK is that you can send custom HTML/CSS/JavaScript to render inside ChatGPT. I built a React component that displays event cards with:

  • Date and time formatting (with timezone handling)
  • Location display
  • Event descriptions
  • Toggle between list and grid views
  • Fullscreen calendar mode

The component uses ChatGPT's window.openai API to communicate back and forth, which handles the theming automatically. Dark mode in ChatGPT? The calendar switches to dark mode. It's seamless.

Development Workflow

OpenAI provides an MCP Inspector tool that lets you test your server locally before deploying. It runs at http://localhost:2091/mcp and gives you a playground to call your tools and see the responses.

The workflow looks like this:

  1. Build the React component with esbuild
  2. Run the MCP server locally
  3. Test with MCP Inspector
  4. Expose with ngrok for ChatGPT testing
  5. Register the connector URL in ChatGPT Developer mode

Once it's working in dev, deploying to production is straightforward—swap ngrok for a real HTTPS endpoint and you're done.

What I Learned

The Good

  • Speed - I went from zero to working prototype in about an hour with OpenCode and Grok
  • AI-assisted development works - Pointing OpenCode at the docs and letting Grok generate code dramatically accelerated development
  • Natural interactions - The conversational interface is genuinely better than clicking through calendars
  • Reusable components - The calendar system I'd already built for the web "just worked" with ChatGPT
  • Developer experience - The MCP Inspector and documentation made iteration fast

The Tricky Parts

  • Local development - ngrok is great for POCs but raises security flags in enterprise environments
  • HTTPS requirements - Everything needs to be served over HTTPS, which means more setup for production
  • Limited debugging - Once the app is running in ChatGPT, visibility into errors is minimal

Should You Build a ChatGPT App?

If you have data or functionality that people query conversationally, absolutely. The barrier to entry is low—if you can build an Express server and a React component, you can build a ChatGPT app.

The platform is brand new (released November 2025), so the ecosystem is still forming. But the foundation is solid, and OpenAI is clearly betting on this as a distribution channel for AI-powered tools.

What's Next

This POC proves the concept works. The next steps would be:

  • Add write capabilities—create events, set reminders
  • Integrate with more data sources—weather, traffic, restaurant availability
  • Deploy to production HTTPS (no more ngrok)
  • Add authentication for private calendar data

For now, it's a working proof-of-concept that shows how quickly you can build on OpenAI's Apps platform. If you're curious about the implementation details, check out the code on GitHub.

Try It Yourself

The Apps SDK is available now in ChatGPT Developer mode. With AI coding assistants like OpenCode and Grok, the barrier to entry is incredibly low. Point them at the docs, describe what you want, and let them generate the scaffolding.

Start with something small, something you'd find useful, and see where it goes. You might be surprised how quickly you can go from idea to working prototype—maybe even during a morning workout.