How I Create AI Demo Videos for My Hackathon Projects

Using a local LLM with vLLM, Microsoft Edge TTS, and AI tools to turn
project demos into clear, engaging videos.

Why I built this workflow

Building a hackathon project is only half the work. You also need to
explain the problem, show the product working, and make the value
obvious to judges.

I wanted a repeatable way to create narrated demo videos without
depending entirely on expensive cloud-based LLM APIs or recording every
voiceover myself.

My workflow combines:

• vLLM to serve a local language model and help write or refine the narration.
• Microsoft Edge TTS to turn the script into spoken audio.
• Other AI tools to help create supporting visuals, diagrams, subtitles, or scene ideas.
• Screen recording and video editing tools to show the real project and assemble the final video.

The goal is not to make an AI-generated video pretend to be the
product. The goal is to explain the real product clearly, using AI to
speed up production.

1. The tools behind the workflow

vLLM: a local LLM for the script

I run a language model locally and serve it through vLLM. I can send
it the project description, feature list, technical stack, and key user
flows.

I use the model to:

• Turn rough project notes into a structured video script.
• Explain technical features in simpler language.
• Write an opening hook and a concise conclusion.
• Break the narration into scenes.
• Refine wording so the voiceover sounds natural when spoken aloud.

vLLM provides an OpenAI-compatible API, which makes it convenient to
connect to scripts and applications that already support that API
format.

Documentation: vLLM documentation

A practical note: local inference is not automatically free. You
still need suitable hardware, and performance depends on the model,
quantization, context length, and available memory.

Microsoft Edge TTS: turning the script into narration

After the script is ready, I pass the narration text to Microsoft Edge
TTS to generate speech.

The Python package edge-tts makes
it straightforward to generate audio with available Microsoft neural
voices.

Why I use it:

• I can generate narration without recording my own voice.
• I can choose from available voices and languages.
• I can regenerate a section after changing the script.
• I can save the output and use it in my video editor.

Important: edge-tts is an unofficial interface to Microsoft's
online text-to-speech service. It is not a fully local TTS engine, so
the narration step requires an internet connection and is subject to the
service's terms and availability.

Other AI tools: supporting assets

I can use other AI tools where they genuinely help---for example, to
create a visual concept, simplify a diagram, suggest scene transitions,
or generate subtitles.

I keep the actual product walkthrough authentic: screenshots and screen
recordings should show the real application, not invented UI.

2. My end-to-end workflow

Step 1 --- Collect project information

I start with the material I already have:

• Project name and one-line summary.
• Problem being solved.
• Target users.
• Main features.
• Technology stack.
• A short list of actions to demonstrate.
• The result or impact I want viewers to remember.

The more concrete the input, the less generic the script will be.

Step 2 --- Generate a scene-by-scene script

I ask the local LLM to structure the video into a few clear sections:

1. Hook: introduce the problem or surprising idea.
2. Problem: explain why the problem matters.
3. Solution: introduce the project.
4. Live demo: show the main user journey.
5. Technology: briefly explain the architecture.
6. Closing: summarize the value and next steps.

I review the script before generating audio. AI-generated claims should
be checked against what the project actually does.

Step 3 --- Generate the voiceover

I send the approved narration to Edge TTS and save the resulting audio
file.

I keep the script divided into scenes rather than generating one huge
audio file. This makes it easier to replace a sentence, adjust pacing,
or rearrange the video later.

Step 4 --- Record the real product

I record the application running and capture the most important
workflows.

A useful demo usually shows:

• The starting screen.
• One complete user journey.
• The most distinctive feature.
• The result produced by the application.
• A brief view of the architecture, if it helps explain the project.

I avoid long loading screens, unnecessary cursor movement, and repeated
actions.

Step 5 --- Add visuals and edit

I combine the screen recording, narration, and supporting assets in a
video editor. I add captions, labels, transitions, and background music
only where they improve clarity.

I also check that the voiceover matches the action on screen. A polished
video is not useful if the narration describes something the viewer
cannot see.

3. Architecture at a glance

The following diagram shows the content-production flow. The project
recording and AI-generated assets join the narration during editing.

flowchart TD
    A[Project notes, features, and tech stack] --> B[Local LLM served by vLLM]
    B --> C[Scene-by-scene demo script]
    C --> D[Review and edit script]
    D --> E[Microsoft Edge TTS]
    E --> F[Voiceover audio]

    G[Real application] --> H[Screen recording]
    I[Other AI tools] --> J[Supporting visuals and assets]

    F --> K[Video editor]
    H --> K
    J --> K
    K --> L[Final hackathon demo video]

4. Why this setup works for hackathons

• Reusable: I can follow the same process for different projects.
• Flexible: I can change the model, voice, visuals, or editor independently.
• More control: I can run the LLM locally instead of sending every script prompt to a hosted LLM API.
• Faster iteration: I can regenerate only the narration section that changed.
• Clearer storytelling: a structured script helps keep the demo focused on the problem and the product.

There are trade-offs. vLLM needs compatible hardware and setup. Edge TTS
relies on an online service. AI visuals can also take time to review. I
use each tool where it saves time rather than adding complexity for its
own sake.

5. What I want to automate next

There is room to take this workflow further:

• Generate a first-draft script from a repository README.
• Turn the script into a scene list with suggested screen actions.
• Generate subtitles automatically.
• Match narration sections to recorded clips.
• Use FFmpeg to automate repetitive editing tasks.
• Export versions with different lengths for a presentation, social post, or project page.

The long-term idea is a pipeline where project information and a screen
recording become the starting point for a nearly finished demo
video---with a human reviewing the story and final edit.

Conclusion

A hackathon project deserves a demo that makes its value easy to
understand. My combination of a local LLM served with vLLM, Microsoft
Edge TTS, and other AI tools helps me create narrated project videos in
a repeatable way.

The important part is the balance: use AI to speed up scripting and
production, but show the real application and keep the claims honest.

Build the project. Tell the story. Show the proof.

Tools and references

• vLLM documentation
• Microsoft Edge TTS Python package (edge-tts)
• FFmpeg documentation