How I Built an AI That Turns Ideas into PowerPoint Slides

What if there is a product which can take your idea, do the research, find the relevant fact & figures and then use that data into nicely crafted PowerPoint presentation?
Almost everyone is using AI (LLMs) to do the research, however, while research has been automated, presentation is not and I personally find it significantly time consuming to create a PowerPoint presentation. So I applied my limited knowledge of AI-driven automation to see if this chore can be automated (90% I would aim for).

This question was the spark for Slider, a web application designed to do just that: turn a single search phrase into a fully-formed, downloadable PowerPoint presentation. This is the story of its development—a journey from a simple idea to a robust, resilient web service, fraught with subtle bugs, architectural pivots, and invaluable lessons in software engineering.

Chapter 1: The Spark of an Idea (The “Why”)

The initial goal was ambitious but clear: create a tool that automates the entire presentation creation pipeline. A user should be able to provide a topic, say, “The Future of Renewable Energy,” and in return, receive a “.pptx” file complete with a title slide, content slides with key points, and even data visualizations like charts and tables. The aim was to save hours of manual work and provide a solid, editable foundation that users could then refine.

Chapter 2: The Initial Architecture (The “How”)

To bring this idea to life, I settled on a modern, decoupled architecture:

- Frontend: A simple HTML form with a sprinkle of vanilla JavaScript.
- Backend: A Python server using FastAPI.
- The AI & Orchestration Layer: Leveraging n8n for workflow automation.
- The Presentation Generator: python-pptx for building slides.

The n8n Workflow

1. FastAPI calls an n8n webhook with the search phrase.
2. n8n generates structured JSON (titles, bullets, mock chart data).
3. JSON is passed back to FastAPI, which builds the presentation.

Chapter 3: First Blood – The “Division by Zero” Bug

Error creating presentation: float floor division by zero

Matplotlib choked when AI returned empty data for charts. Fix: validate chart data before rendering.

Chapter 4: The Silent Killer – The Timeout Issue

httpx default timeout (60s) killed long AI workflows. Fix:

async with httpx.AsyncClient(timeout=None) as client:
    response = await client.post(N8N_WEBHOOK_URL, json=webhook_payload)

Chapter 5: Improving the User Experience (The “Feel”)

Fixing backend logic wasn’t enough—the real bottleneck was how it felt to users. An app that quietly sits there for minutes without feedback is indistinguishable from one that’s broken. I knew I had to design for perceived performance, not just raw speed. This led to the introduction of a dynamic loading system:

A spinner to visually confirm that the request was in progress.
Rotating status updates such as “Contacting AI assistant…”, “Generating slides…”, and “Almost done…”.
Clear error messages if something failed, so users weren’t left guessing.

This turned waiting into an interactive experience rather than a frustrating black hole. Users reported that even if it took a couple of minutes, they trusted the process because they could “see” progress happening. The takeaway: sometimes the difference between a tool that feels clunky and one that feels professional isn’t speed—it’s communication.

Chapter 6: The Devil in the Details – Fonts and Aesthetics

Once the system was stable, smaller issues came into focus—and they mattered more than I expected. Font issues: My Docker container didn’t include the Segoe UI font that PowerPoint defaults to. As a result, charts rendered with odd-looking fallback fonts, making them look unpolished. The fix was to install fonts and rebuild the font cache inside the container. Invisible text bug: Some slides came out with black text on dark backgrounds. This wasn’t a crash—it was worse, because users thought the tool worked, but the slides were unreadable. The workaround was a brute-force loop that:

Iterated through every shape on every slide.
Explicitly set the font color to white.
Enforced consistent readability across the deck.

This phase drove home the lesson that polish matters. The difference between a hacky prototype and a product people actually use often lies in those small, edge-case fixes that elevate the experience.

def is_valid_pptx(file_content: bytes) -> bool:
    if not file_content:
        return False
    try:
        file_stream = io.BytesIO(file_content)
        Presentation(file_stream)
        return True
    except Exception:
        return False

Conclusion: Lessons Learned and The Road Ahead

Defensive Programming: Validate all data.
Know Your Tools: Defaults matter (timeouts, libraries).
User Experience is Paramount: Feedback beats silence.
Build for Failure: Handle errors gracefully.

The road ahead for Slider is exciting—more layouts, authentication, maybe Google Slides integration. But the foundation is now strong, built not just on code, but on lessons from every bug squashed.

You can check out the source code for this project on GitHub. What features would you like to see next? Let me know in the comments!

AI-Powered PPT Generator