How I Automated My Podcast Post-Production Without Losing Sleep

I love hitting the record button. There is something genuinely magical about sitting down, putting on a good pair of headphones, and diving into a conversation. But the moment the recording stops, the magic usually fades.

I was struggling with the sheer volume of post-production work required to get an episode out the door. Writing detailed show notes, crafting the perfect title, and formatting descriptions felt like a second full-time job. I realized I was spending more time doing administrative work than actually creating content. So I decided to build something to handle the heavy lifting.

The Hidden Cost of Podcast Admin

When you are a solo creator or part of a small team, time is your most finite resource. Ignoring the post-production bottleneck usually leads to one of two outcomes: you either burn out and stop publishing, or you rush the metadata, resulting in poor discoverability and a frustrating listener experience.

Writing good show notes is not just about summarizing what was said. It is about structuring the content for search engines, highlighting key takeaways, and providing timestamps so listeners can navigate the audio easily. Podcast directories rely heavily on text metadata to index audio files. Doing this manually takes me about 40 minutes per episode. Multiply that by a weekly publishing schedule, and it is easy to see why so many great podcasts fade away after a few months.

Building an Edge AI Pipeline

I knew I wanted to use AI to solve this, but I did not want to build a heavy, slow backend. Podcast transcripts are long, and passing them through a traditional serverless function often resulted in timeout errors or sluggish UI updates. I needed an architecture that could handle large context windows with minimal latency.

I decided to build PodCrisp using Cloudflare Workers, leveraging their AI inference capabilities at the edge. By running the AI models at the edge, I could avoid cold starts and keep the processing geographically closer to the user, which drastically improved the perceived performance.

Let's look at how I structured 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' },
    });
  },
};

In this worker, I take the raw transcript from the request body. The secret sauce here is the system prompt. Instead of just asking the AI to "summarize this," I give it a strict schema to follow. I want a brief episode summary, 5 to 7 key takeaways, estimated timestamps based on content flow, and a list of resources.

I am using the Llama 3 8B Instruct model via Cloudflare Workers AI. By setting max_tokens to 800, I ensure the response is concise and does not run away with the context window. The edge deployment means this entire process, even for a 45-minute episode transcript, resolves in just a few seconds.

I also applied a similar prompt engineering approach to the title generator, which allows users to select different tones:

// 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.`
  };
}

By separating the tone variable, the tool can generate everything from highly technical deep-dive titles to casual, conversational hooks without needing entirely different backend logic.

Practical Results and Trade-offs

The results have been genuinely helpful for my own workflow. What works exceptionally well is the consistency of the structured output. Because the system prompt is so rigid, I rarely have to reformat the generated markdown before pasting it into my podcast hosting platform.

What surprised me was how well the model handles conversational shifts to estimate timestamps. It is not perfectly accurate down to the exact second, but it gives a highly usable starting point that saves me from having to listen to the audio again just to find chapter markers.

If I were to change something about the architecture, I would implement a more robust pre-processing step. Right now, I pass the raw transcript directly to the model. In the future, I would add a lightweight cleanup step to remove transcript artifacts, like filler words or overlapping speech, before it hits the AI model. This would likely improve the accuracy of the timestamps and the readability of the summary.

Wrapping Up

I ended up packaging these tools into PodCrisp, a suite of AI podcast tools that includes show notes generation, script outlining, and SEO keyword suggestions. If you are currently staring at a blank text editor trying to come up with a catchy name for your next episode, I built a free Podcast Title Generator to help you brainstorm. You can check it out and generate some options at https://podcrisp.com/free-tools/title-generator.

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