How I Built an Edge AI Pipeline to Automate Podcast Admin

When I first launched my indie developer podcast, I thought the hard part was getting guests and hitting record. I was wrong. The real time sink was everything that happened after the recording stopped. I would spend two hours writing show notes, agonizing over the episode title, and trying to extract SEO keywords from the conversation. It was draining the fun out of creating content. I realized I was spending 80% of my time on administrative tasks and only 20% on actual creative work. So I decided to build something.

The Podcast Admin Tax

The problem with podcast post-production isn't just that it takes time; it's the cognitive load. After a 60-minute deep-dive conversation, my brain is usually fried. Asking me to immediately pivot into a meticulous copywriter to summarize key takeaways, estimate timestamps, and craft a curiosity-inducing title is a recipe for burnout.

The cost of ignoring this bottleneck is inconsistency. When the admin work feels like a chore, episodes get delayed, descriptions get lazy, and titles become generic. I needed a way to bridge the gap between raw audio and published metadata without losing my sanity or compromising on quality.

Building an Edge AI Pipeline

I wanted the processing to be fast and globally accessible, so I built the backend for my tools on Cloudflare Workers. Instead of routing requests to a centralized US-based server, running AI inference at the edge means the heavy lifting happens closer to the user, drastically reducing latency for the initial response.

The first piece of the puzzle was the title generator. Crafting a good title is an art, and I wanted to ensure the AI didn't just generate generic clickbait. I approached this through strict prompt engineering, forcing the model to adhere to specific structural rules.

// 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
);

By explicitly banning clickbait that overpromises and enforcing a word count, the output quality jumped significantly. It gives me options that are actually usable, rather than having to rewrite them from scratch.

The second, and heavier, piece of the pipeline is the show notes generator. This takes a raw transcript and structures it into a readable format. Here is the core Cloudflare Worker handling the inference:

// 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 system prompt here does the heavy lifting. By dictating the exact markdown structure I want—Summary, Takeaways, Timestamps, and Resources—the model knows exactly how to parse the unstructured transcript. I set max_tokens to 800 to ensure it doesn't ramble, keeping the summary punchy.

Practical Results and Trade-offs

The results have been a massive improvement for my own workflow. What used to take me two hours of post-recording admin now takes about 15 minutes. I review the AI-generated show notes, tweak a few timestamps, and I'm done. I also use the SEO keyword suggestions feature to quickly tag my episode pages, which takes seconds instead of manual brainstorming.

The biggest surprise was how well the edge inference handled the context of long transcripts. I initially worried that running a smaller, faster model at the edge would result in lower quality summaries compared to massive cloud-based models, but the structured prompts kept it highly accurate and relevant.

If I were to change one thing about the architecture, I'd probably implement a caching layer for the SEO keyword suggestions. Since those suggestions are based on the general topic rather than the specific transcript, caching them could save a few redundant inference calls and speed up the UI even more.

Automate Your Own Workflow

If you're struggling with the post-production bottleneck and want to test out some of these prompt structures, I've packaged the title generation logic into a free tool. You can try the Podcast Title Generator to get a few structured, non-clickbait options for your next episode.

---

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