How to Automate On-Brand Slide Decks with AI and Gamma

Can AI turn a form into a finished, on-brand slide deck?

Yes. Fill in a form, hit submit, and a few minutes later an email arrives with a finished Gamma deck, A4 document, or social carousel, already in the right brand's theme, already split into proper slides. Nobody opens Gamma's editor, picks a theme, or decides where to break the text. Every one of those calls got made once, when the workflow was built, not every time someone needs a deck.

That's the workflow I built and still run for a team producing decks across several brands. Here's what actually made that possible, and where I had to be careful.

Why every new deck means re-deciding the basics

Before this existed, "make a deck" wasn't one decision, it was four. Which brand's theme? 16:9 for a client, A4 for a document, or portrait for social? And how do you split a page of text into something that reads as slides instead of a dumped paragraph?

Those four decisions got made fresh every time, usually by whoever needed the deck that day, not by whoever knew Gamma well. The predictable result: wrong theme, wrong aspect ratio, and body text pasted in as one long block with no slide breaks. None of that looked professional, but it wasn't really anyone's fault. Whoever built the deck that day usually wasn't a Gamma power user, so there was no reason they'd know its defaults.

That's the part worth automating. Not the slide design itself, Gamma already does that well. The decisions that happen before Gamma ever sees the text.

The approach: one form, every decision made up front

The fix was a single bilingual form that collects everything at once, so nobody has to remember Gamma's rules mid-task. Text, processing mode (generate, condense, or preserve structure), output format, target brand, language, slide count, and optional extra instructions, all in one submission.

After that, the workflow runs on its own. It translates the form's plain-language choices into Gamma API parameters, prepares the text for slides, calls the Gamma API, waits for the job to finish, and emails the result. Preview link, download link, no further interaction needed.

I'd worked with the Gamma API before, on a content repurposing pipeline that turns podcast audio into slides and social cards, and was surprised how well and how simply it works once you know the parameter shape. Building a dedicated Gamma creator on top of that experience was the natural next step, not for one use case this time, but as a tool the whole team could use.

From form to API: mapping brand to theme with a lookup

The form speaks the user's language: brand names, readable format labels, mode options in plain German and English. The Gamma API wants theme IDs, folder IDs, and language codes. Someone has to translate between those two worlds, and it shouldn't be a person doing it by hand for every submission.

I solved it with an Edit Fields node that scans the form's labels and maps them to the matching Gamma parameters through a lookup table. Each brand has one fixed entry: theme ID, folder ID. Add a new brand, add one mapping row. Nothing else in the pipeline changes. That's the whole trick, and it's the reason the workflow scales to more brands without more logic.

Folder discipline inside Gamma mattered more than I expected, too. Without a folder per brand, every generated asset piles into one place and finding anything later gets slow. Each brand's folder ID lives right next to its theme ID in the same mapping.

Deciding the output format

Deck (16:9) and document (A4) are direct paths straight from the first form. Social gets a second, short form step: pick the aspect ratio, 1:1, 4:5, or 9:16.

I went with that two-step form on purpose, even though a single longer form would have been less work to build. Someone putting together a client deck shouldn't have to scroll past social-format options they don't need that day.

The text prep: an agent that turns text into slide-sized chunks

Gamma generates decks from text, but raw input has to be split into slide-sized pieces first, or it renders as one dense wall of text on a single slide. A LangChain agent running GPT-4.1-mini handles that split. Its system prompt is tightly scoped: preserve or impose structure, don't change the content, don't add anything, mark where slides break.

Behavior shifts with the mode picked on the form. Generate expands a short topic into a full outline worth of slides. Condense trims existing content down to the essentials. Preserve restructures the text into slide chunks without touching the substance at all.

GPT-4.1-mini was the cheap, capable option when I built this, and this step is pure sorting work, not creative writing. It's held up since. I haven't touched it, because there's no reason to change a step that costs almost nothing and hasn't broken.

The part I was actually careful about: the model must never quietly rewrite or invent content. To the person using the form, this step is a black box, text goes in, a deck comes out. If the model started adding a sentence here or softening a claim there, nobody would catch it right away. That's exactly why the prompt is as restrictive as it gets, split and mark, don't touch anything else.

The delivery: why email beats chat here

Once the API call goes out, the workflow polls the job status on a regular interval until Gamma reports the asset is ready. Plain polling, nothing clever, and it's been reliable the whole time it's run.

Early on I sent a chat notification and an email in parallel, mostly to confirm runs were actually completing. The chat channel is gone now. Email carries the real confirmation: an HTML message with the preview link and the download link, and nothing else competing for attention in a busy channel.

Proof: what this actually runs in production

This isn't a hypothetical setup, it's a live workflow. Stack: n8n orchestrating everything, the Gamma API for generation, a LangChain agent on GPT-4.1-mini for text prep. Built solo in about two weeks, and it's been in production since.

Submit the form and wait briefly. What comes back: a Gamma asset in the requested format (16:9 deck, A4 document, or social portrait), in the correct brand theme with the right logo, colors, and font, text rendered as actual structured slides instead of a dumped paragraph, plus a preview link for browser editing and a download link as PPTX or PDF. All of it delivered by email.

Adoption is the result I care about most. The workflow landed well with the team and made deck creation noticeably easier for people who don't touch Gamma often. Before it existed, almost everyone got something wrong: the wrong theme, the wrong format, or body text dumped in with no slide breaks. That stopped happening.

What I'd change if I rebuilt it today: fork the form more aggressively so it guides the user further, and allow file and image uploads so the workflow isn't text-only. The core pipeline works. The room for improvement is on the input side, not in how Gamma renders the output.

If you're building something similar and want to compare notes on the underlying platform choice, I've written about n8n versus make.com for exactly this kind of workflow, and about five beginner n8n workflows if you're starting from scratch. The same content pipeline that got me comfortable with the Gamma API also feeds Content Machine, a related agent workflow worth a look if slide generation is only one piece of what you're trying to automate.