Meeting Transcripts to AI-Generated Client Presentations

1. Create presentation & set up database — a form captures client name and transcript URL; the workflow copies a Google Slides template and logs details to a Google Sheets database.
2. Generate presentation plan — an AI agent reads the transcript, identifies pain points, maps them to the solution, and saves a structured nine-slide plan as a Google Doc.
3. Illustrations generator — a second agent writes six image prompts (slides 3–8); an AI image model generates the visuals, which are uploaded to Google Drive.
4. Edit slides (text) — a formatting agent produces structured slide JSON, a JavaScript node cleans it, and the Slides API fills text placeholders by Object ID.
5. Update slides (images) — illustrations are re-hosted on ImgBB for direct URLs and inserted into image placeholders via the Slides API; a merge node confirms completion.

• n8n — workflow orchestration (107 nodes, self-hosted)
• Google Slides API — template copying, text replacement, and image insertion
• Google Docs — transcript source and saved presentation plan
• Google Drive — template duplication and generated-image storage
• Google Sheets — central tracking database (main, images, and client sheets)
• OpenAI & Google Gemini (via n8n LangChain agents) — plan generation, text formatting, and image prompts
• Flux / "nanobanana" (via OpenRouter) — AI image generation
• ImgBB — image hosting to produce Slides-compatible direct URLs
• n8n Form Trigger — client and transcript intake
• Structured Output Parser & Code node — schema enforcement and JSON cleanup

The brief: a finished, personalised deck from a transcript, with no manual slide-building.

The client wanted to compress the most tedious part of their sales and consulting motion — turning a discovery-call transcript into a polished, client-ready presentation — into a single automated flow. The output had to be genuinely personalised (mapping this prospect's stated problems to the right solution), fully branded, illustrated with relevant visuals, and delivered as an editable Google Slides deck. We built this as a 107-node n8n workflow structured into five sequential stages, using Google Sheets as the central tracking database so every presentation's progress is visible and recoverable.

Stage 1 — Create presentation and set up the database. An n8n form captures the essentials: the client's name and a link to the meeting transcript stored as a Google Doc. The workflow then creates a brand-new deck by copying a pre-configured Google Slides template via the Drive API (the template ID is swappable, so teams use their own design), and writes all the details to a Google Sheets database — a main sheet plus dedicated images and client sheets that act as the central hub. Creating the row automatically triggers the next stage.

Stage 2 — Generate the presentation plan. The transcript is pulled from Google Docs and handed to an AI agent that acts as a sales-presentation strategist. It analyses the conversation to surface the client's pain points, maps them to the company's capabilities and value propositions, and produces a detailed, structured nine-slide blueprint — cover, table of contents, problem and solution slides, and a clear next-steps slide. The full plan is saved as a Google Doc for reference and review, and the database is updated to trigger illustration generation.

Stage 3 — Illustrations generator. A second agent reads the plan and writes exactly six image prompts — one each for the content slides (3 through 8), deliberately skipping the cover, contents, and next-steps slides. Each prompt is sent to an AI image model (Flux / "nanobanana" via OpenRouter) running in synchronous mode, which returns images in base64. These are converted to binary files and uploaded to Google Drive, with the database updated to trigger the text-update stage.

Stage 4 — Edit slides (text). A "final text formatting" agent converts the plan into a precise, deeply structured JSON object containing every slide's title, subtitle, bullet points (capped for readability), and next-steps detail. A key engineering decision here: a JavaScript node — not an output parser — cleans and shapes this output, because the deeply nested JSON structure tends to overwhelm an AI parser's consistency. The native Google Slides node then replaces every text placeholder in the deck by its unique Object ID, so the right content lands in the right element, and triggers the final stage.

Stage 5 — Update slides (images). The workflow retrieves the deck's image-placeholder Object IDs, downloads the generated illustrations from Drive, and — working around a real-world limitation where Google Drive URLs don't function in Slides automation — re-hosts each image on ImgBB to obtain a direct .png URL. Those URLs are then used to replace the image placeholders via the Slides API. A merge node ensures every slide is processed before the workflow reports completion.

Why this design works. The five-stage split, coordinated through a Google Sheets ledger, makes a complex multi-asset process reliable and observable — each stage updates a status and triggers the next, so a run can be tracked or resumed at any point. Separating plan generation from text formatting and image generation lets each agent do one job well, and the structured-plan-first approach means both the copy and the visuals derive from the same coherent blueprint. The pipeline is also pragmatically engineered: using JavaScript for the brittle nested-JSON step and ImgBB to solve the Drive-URL problem are exactly the kinds of fixes that separate a demo from something that runs in production. The result is a personalised, branded, illustrated deck generated end-to-end from a single transcript — equally useful for sales pitch decks, consulting proposals, campaign presentations, product-research readouts, and training materials.