CASE STUDY
How we built RenderATL's MCP server on Netlify, and opened our CFP to AI agents
RenderATL became the first major tech conference to accept talk proposals from AI agents. Here's how we built our MCP server on Netlify, what we designed in, and what we learned.
Justin Samuels, Founder and CEO, Silicon South Group
November 9, 2026
6 min read
Every conference talks about agents. We built for them.
This fall, RenderATL became the first major tech conference to accept Call for Papers submissions from AI agents. For the opening window of the RenderATL 2027 CFP, through November 1, agents were the only ones who could apply.
A speaker tells their agent what they want to talk about. The agent reads our CFP guidance, drafts the proposal with them, and submits it through our MCP server at mcp.renderatl.com/cfp. No forms, no portals, no pasting the same bio for the tenth time.
We built it on Netlify, and the build took two hours. More than 100 proposals came in on the first day. Here's how.
The problem: the front door was still a form
The CFP is the front door to RenderATL. Every year, thousands of builders across the South and beyond decide whether to walk through it, and every year that meant a web form.
Meanwhile, the people we serve were changing how they work. Engineers, designers and founders now do real work through Claude, ChatGPT and Cursor. We program AI talks every year, and AI now runs through every track instead of sitting in one. It felt wrong for the conference itself to still run on copy and paste.
There was a real risk on the other side. Make submissions too easy and you invite a flood of generic, machine-written proposals that bury your review committee. So we set two goals:
- Make it easy for an agent to help a real speaker apply.
- Keep a human in the loop and keep the quality bar where it is.
Why Netlify
We didn't want to stand up and babysit servers for a CFP. We wanted to write the tools, push, and have them live on our own domain.
Netlify fit because:
- We already build on it. Netlify Functions already power parts of our stack, including the one that feeds Atlanta Tech Week's event listings.
- Serverless fits the shape of an MCP server. An MCP request is a short burst of work: validate input, call a tool, return a result. That maps cleanly onto functions that scale up when a CFP announcement lands and cost nothing when it's quiet.
- Git push is the deploy. Every change to a tool or its guidance is a commit, with a deploy preview to test against before it goes live.
- Our domain, our front door. The server lives at mcp.renderatl.com, not on a vendor URL.
Netlify is also part of the RenderATL family. Netlify CEO Mathias Biilmann has spoken on our stage in 2024, 2025 and 2026, and Netlify CTO Dana Lawson spoke in 2025. Building on the platform our community already ships with was an easy call.
How we built it
1. We wrote the spec first. Before any code, we wrote down the rules. Read tools are open to anyone. Write tools are gated by identity. Nothing reaches a reviewer until a human confirms it. And every proposal has to clear the same quality bar a human applicant would.
2. Two servers on one subdomain. The root, mcp.renderatl.com, is a small directory server with one tool, list_services, that tells an agent what RenderATL offers over MCP and where to go. The CFP itself lives at mcp.renderatl.com/cfp. Keeping them apart means the directory can grow without touching the submission path.
3. Two tools that do one job each. The CFP server exposes submit_cfp and get_status. That's it. A small surface is easier for agents to use correctly and easier for us to secure.
submit_cfp takes a strict schema:
{
"speakerName": "Your Name",
"email": "you@example.com",
"company": "Your Company",
"talkTitle": "What attendees will be able to do afterward",
"abstract": "Up to 5,000 characters",
"format": "talk - 25 min",
"topic": "Web",
"level": "intermediate",
"bio": "Up to 2,000 characters",
"linkedinUrl": "https://www.linkedin.com/in/you",
"previousTalkUrl": "https://example.com/your-talk",
"submissionCode": "your-submission-code"
}Formats are limited to talk - 25 min, talk - 10 min and workshop. Topics are limited to Web, Design and Go To Market. There is no AI category on purpose: AI is an expectation now, so it shows up inside every topic. Every field except the previous-talk link is required, and URLs have to be real https links.
4. The server teaches the agent what a good proposal looks like. This is the part we're proudest of. MCP lets a server send instructions to the agent that connects to it, so ours carries the same guidance a program chair would give you over coffee: teach something attendees can't get from a README, say who the session is for and what they'll be able to do afterward, match the level honestly, and don't pitch a product. The agent reads that before it drafts anything, so the proposals that reach us are shaped by our bar, not by a generic prompt.
5. A human confirms every submission. When an agent calls submit_cfp, nothing goes to reviewers yet. The speaker gets an email with a confirmation link that expires in 48 hours, and they click it themselves. Only then is the proposal received, and a second email gives them a status id. get_status needs the speaker's email, that status id and the submission code, all three matching. It can't list other speakers and it can't change a proposal.
6. Running it on Netlify. The whole server is a single Netlify Function, so any remote MCP client can connect to it by URL with nothing for us to provision or scale. Submissions land in Airtable, so a confirmed proposal shows up as a record we can review right away. Netlify deploys on every git push, so changing a tool or its guidance is just a commit. From start to a working server, the build took two hours.
7. We tested it with a real agent before launch. On October 21, we connected the server to Claude as a custom connector and ran six live test proposals through it, covering all three formats, all three topics and all three levels. Every status check came back correctly.
The most useful lesson came from the failures. Twice the agent sent a bad request: once without a topic, once with a plain "talk" format. Both times the strict schema rejected the call before anything was saved, and the agent fixed it and tried again. Tight enums felt fussy when we wrote them. They turned out to be the guardrail that kept bad data out.
Results
- First major tech conference to accept CFP submissions from AI agents.
- Two hours from start to a working MCP server on Netlify.
- Over 100 proposals submitted by agents in the first day.
- Zero bad records from malformed requests during testing, because the schema rejects them before anything is written.
What's next
The CFP was the first door. Next we want attendees to be able to buy tickets the same way. The plan is a small commerce layer on the same server: a tool that lists what's available, a tool that creates a secure checkout, and a tool that confirms the order. The payment itself never happens inside the chat. The agent hands the buyer a secure checkout page, and our backend confirms the purchase.
We're also tracking how agent-assisted proposals compare to human-written ones on acceptance and on how the talks land on stage. We'll share what we find.
Build yours, then come show us
If you run a community, an event or a product with a front door, an MCP server on Netlify is an afternoon of work. Ours took two hours, and it's a real signal to the people you serve.
Want to see ours in action? Point your agent at mcp.renderatl.com/cfp and pitch a talk for RenderATL 2027, August 18 and 19 in Atlanta. Then come build with us in person.
Be in the room where what's next gets built
RenderATL 2027 is August 18–19 in Atlanta: two days where the world's builders meet the culture of the South. Grab your ticket to learn what's next, meet the people shaping it, and leave with the connections you'll keep building with. Or partner with us to put your brand, product, and hiring team directly in front of the engineers, founders, and tech leaders in the room.