How I Built an Edge AI Pipeline to Automate Podcast Show Notes

When I first started podcasting, I thought the hard part was getting guests or coming up with topics. I was wrong. The real bottleneck wasn't the recording; it was the aftermath. I would spend an hour recording a great conversation, and then another two hours staring at a blank text editor, trying to write show notes, pull out timestamps, and craft a compelling summary. By the time I was ready to publish, the excitement of the episode was completely gone. I was dreading the admin work more than the actual content creation. So I decided to build something.

The Post-Production Admin Trap

The post-production admin work is a silent podcast killer. Show notes aren't just a nice-to-have; they are the textual footprint of your audio. They are crucial for SEO, making your episodes discoverable on search engines, and they provide a navigable experience for listeners who want to jump to specific topics. But writing them manually is incredibly tedious. You have to listen to the episode again, pause constantly, and format everything.

The cost of ignoring this is high. Many talented podcasters burn out and quit simply because the gap between hitting "stop" on the recording and hitting "publish" is filled with hours of tedious formatting. I needed to shrink that gap and automate the boring parts.

Building an Edge AI Pipeline

To solve this, I needed an automated pipeline that could take a raw transcript and turn it into structured, useful show notes. I didn't want to manage heavy infrastructure or deal with cold starts, so I turned to Cloudflare Workers. Running AI inference at the edge was a game-changer for this specific use case. It keeps latency low and avoids the traditional serverless cold-start penalties.

Here is a simplified look at the Cloudflare Worker that handles the show notes generation:

// 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 core of this approach relies heavily on prompt engineering. By defining a strict system prompt, I force the model to output a specific Markdown structure. I explicitly ask for a 2-3 sentence summary, 5-7 bullet points for takeaways, estimated timestamps, and resources.

One of the most important technical decisions was setting max_tokens: 800. Early on, without this limit, the model would sometimes ramble or hallucinate extra sections. Constraining the output forces the AI to be concise and stick to the most important points. Because Cloudflare Workers run on the edge, the inference happens close to the user, making the whole process feel instantaneous compared to routing through a centralized API.

Beyond show notes, generating good titles requires a different prompt strategy. Here is how I approach the title generation logic to ensure we get clickable but honest results:

// 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 key here is the tone variable. By parameterizing the tone, I can reuse the same function for an inspirational episode or a highly technical deep dive. The rules in the system prompt—like avoiding clickbait that overpromises—are crucial for maintaining trust with the audience.

Practical Results and Workflow Shifts

The results of this automation have completely changed my workflow. What used to take two hours of paused listening and typing now takes about five minutes of reviewing and tweaking the AI's output. The structured prompt works surprisingly well, capturing the essence of the conversation without getting bogged down in conversational filler.

What surprised me most was how much mental energy this saved. I no longer feel the "post-recording dread." I can record three episodes in a row, run them through the pipeline, and just do a final polish later. The edge deployment means the API responds quickly, keeping the momentum going.

If I were to change one thing, I would add more granular control over the tone of the show notes. Right now, it defaults to a professional but accessible tone, but some podcasts might want something more casual or highly technical. I've since expanded the platform to include episode script outline generators and SEO keyword suggestions to round out the pre-production and publishing phases.

Automating the Rest of the Process

If you are a podcaster or content creator dealing with this exact bottleneck, I've packaged some of these tools into a suite called PodCrisp. While the show notes pipeline is the backend engine of my workflow, I also built a free Podcast Title Generator to help with the other half of the publishing headache. Crafting a title that drives clicks without resorting to cheap clickbait is tough, so I built a tool that generates multiple style options based on your topic and desired tone.

You can try the free Podcast Title Generator here: https://podcrisp.com/free-tools/title-generator

---

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