Using a local LLM with vLLM, Microsoft Edge TTS, and AI tools to turn project demos into clear, engaging videos.
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:
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.
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:
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.
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:
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.
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.
I start with the material I already have:
The more concrete the input, the less generic the script will be.
I ask the local LLM to structure the video into a few clear sections:
I review the script before generating audio. AI-generated claims should
be checked against what the project actually does.
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.
I record the application running and capture the most important
workflows.
A useful demo usually shows:
I avoid long screens, unnecessary cursor movement, and repeated
actions.
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.
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]
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.
There is room to take this workflow further:
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.
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.