How I Built a Serverless AI Tool for Podcast Show Notes

I was struggling with the post-production bottleneck. I love recording podcasts, but the moment the recording stops, the dread sets in. Writing show notes, crafting clickable titles, and extracting key takeaways took me hours per episode. I was spending more time doing admin work than actually creating content. I tried a few generic AI wrappers, but they lacked the specific formatting I needed for podcast directories. So I decided to build something.

The Problem with Podcast Metadata

The problem isn't just about saving time; it's about consistency and discoverability. If you skip writing show notes, your episode gets buried. Search engines and podcast directories rely on text metadata to understand what your episode is about. A 45-minute audio file is essentially a black box to an algorithm.

Furthermore, a bad title means a low click-through rate. You could have the most insightful conversation in the world, but if the title is just "Episode 42 - Interview with John," nobody is clicking play. The cost of ignoring this is a stagnant audience and wasted recording effort. You need a system that turns raw audio transcripts into structured, SEO-friendly metadata without burning out your brain.

Building an Edge AI Pipeline

I wanted to build a tool that handles this metadata generation efficiently. I chose Cloudflare Workers because running AI inference at the edge means low latency for users globally, and I didn't want to manage traditional server infrastructure.

Let's look at how I structured the prompt engineering for the title generator. Generating a good title isn't just about asking the AI for a title. It's about setting strict constraints. Here is the function I use to build the prompt for the podcast title generator:

// Prompt engineering for podcast title generation
function buildTitlePrompt(topic, tone, count) {
  return {
    system: `You are an expert podcast producer. Generate compelling titles.
Rules:
- 5-10 words each
- Use curiosity gaps, numbers, or strong hooks
- Match the tone: ${tone}
- No clickbait that overpromises
- Format as numbered list`,
    user: `Episode topic: ${topic}

Generate ${count} title options that make someone want to click play.`
  };
}

// Example: generate 5 titles for a bootstrapping episode
const prompt = buildTitlePrompt(
  "How to start a podcast with zero budget",
  "inspirational",
  5
);

The system prompt sets the persona and strict rules like word count and curiosity gaps. The user prompt provides the specific topic and count. This structured approach prevents the AI from generating generic, clickbaity, or overly long titles.

For the heavier lifting, like converting a full transcript into structured show notes, I use the Workers AI platform directly. Here is a simplified version of the Cloudflare Worker that handles the show notes generation pipeline:

// Show notes generation pipeline (Cloudflare Workers + AI)
export default {
  async fetch(request, env) {
    const { transcript } = await request.json();

    // Call AI model for structured show notes
    const response = await env.AI.run('@cf/meta/llama-3-8b-instruct', {
      messages: [
        {
          role: 'system',
          content: `Convert podcast transcripts to show notes:
## Episode Summary (2-3 sentences)
## Key Takeaways (5-7 bullet points)
## Timestamps (estimate from content flow)
## Resources Mentioned`
        },
        { role: 'user', content: transcript }
      ],
      max_tokens: 800,
    });

    return new Response(JSON.stringify(response), {
      headers: { 'Content-Type': 'application/json' },
    });
  },
};

The worker receives the raw transcript via a POST request. It uses the @cf/meta/llama-3-8b-instruct model to process the text. Notice the system prompt explicitly defines the markdown structure: Summary, Key Takeaways, Timestamps, and Resources. By enforcing this structure in the system prompt, the output is consistently formatted and ready to be pasted directly into a podcast hosting platform. I set max_tokens to 800 to ensure the model has enough room for a detailed summary without running into truncation issues.

Practical Results and Iterations

What worked? The structured prompting completely eliminated the hallucinated timestamps issue I had with earlier, less constrained prompts. By forcing the AI to estimate timestamps based on content flow, the output is actually useful.

What surprised me was how much of a difference the tone parameter made in the title generator. Passing "inspirational" versus "technical" yielded vastly different hooks, giving me real variety to choose from.

If I were to change anything, I'd probably add a post-processing step to automatically verify that the generated SEO keyword suggestions actually match the transcript content, rather than just relying on the model's semantic understanding. But for now, the edge-based pipeline is fast and reliable enough for my daily workflow.

Try the Title Generator

I've packaged these tools into PodCrisp to help other podcasters streamline their post-production. If you want to test out the title generation logic we discussed, you can try the free Podcast Title Generator (https://podcrisp.com/free-tools/title-generator) on my site. It's a great way to see how structured prompting changes the output quality before you commit to any workflow changes.

---

Full disclosure: I'm the developer of PodCrisp. I built this because I needed it myself.