FramePilot: Turning a Video Brief Into a Billable Project

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

An AI-powered business assistant for freelance video creators, built with Gemma and Ollama.

Freelance video creators spend a lot of time doing work that happens before the camera even comes out.

A client sends a rough message. You figure out exactly what they need, decide what to charge, prepare a proposal, plan the shoot, define revisions, and work out when everything should be delivered.

That is a lot of business planning before the actual creative work begins.

For the Hacktoberfest 2026 Week 2 Side Hustle challenge, I built FramePilot — a local-first AI assistant that helps freelance videographers and small production teams turn a rough client brief into a structured, actionable project plan.

What I Built

FramePilot takes a client's project brief and helps turn it into a practical project pack.

Here is what it can prepare:

• Three service packages: Starter, Standard, and Premium, with different deliverables and revision policies.
• Project scope: A concise project summary, positioning, and clear boundaries to help prevent scope creep.
• Production checklists: Tasks for pre-production, shoot day, and post-production.
• Project timeline: Suggested stages, timing, and client hand-offs.
• Transparent pricing estimates: Calculated from the creator's own hours, hourly rate, expenses, and overhead.
• Client-ready pitch: A starting message that the creator can review and adapt before sending.
• Potential upsells: Relevant optional additions that could bring more value to the client.

The important part is that FramePilot doesn't ask an AI model to invent market prices. The app calculates its price anchors separately using the creator's own assumptions. The results are planning estimates, not verified market rates.

Who would pay for it?

I built FramePilot with independent videographers, freelance editors, content creators, and small video production teams in mind.

Imagine a creator who is great at shooting and editing but doesn't enjoy preparing proposals or figuring out how to package their services. FramePilot helps them start with a more organized plan, communicate their value, and spend less time on repetitive administrative work.

The idea is simple: make the business side of creative work easier, so creators can focus more on creating.

Demo

Project repository:

bazik-0 / frame-pilot

FramePilot

Make the brief billable. FramePilot is a local-first business kit for freelance video creators and small production teams. It turns a rough client brief into scoped service packages, a transparent pricing guide, a production checklist, a hand-off timeline and a first client message.

Built for the Hacktoberfest 2026 Week 2 Side Hustle challenge: small, specific, useful software that someone could plausibly pay for.

What's in the MVP

• Client-ready project pack: summary, positioning, three offer tiers, scope guardrails, clarifying questions and one relevant upsell.
• Shoot workflow: checklists for pre-production, shoot day and post-production, plus a timeline with client hand-offs.
• Transparent price anchors: calculated from hours, hourly rate, fixed expenses and overhead that the creator supplies. They are not presented as verified market rates.
• Export: download the project pack as Markdown; copy the pitch, checklist or pricing assumptions.
• Local inference: by default, a Gemma open-weight model runs through Ollama on the…

View on GitHub

FramePilot currently runs locally rather than through a public hosted demo. The project includes a sample preview so people can explore the interface without running an AI model.

To try live generation on a machine with Python and Ollama installed:

ollama pull gemma3:4b
python app.py

Then open:

http://127.0.0.1:8000

A public screen recording can be added here once available: [ADD YOUR DEMO VIDEO LINK]

Code

GitHub:

The project uses Python's standard library for its local HTTP server, with a browser-based interface built using HTML, CSS, and JavaScript. No external Python web framework is required.

The repository includes the application, setup instructions, and supporting project documentation.

How I Built It

The central AI component is Gemma 3 4B, run locally through Ollama.

The architecture is intentionally straightforward:

1. The user enters the client brief and planning assumptions in the browser.
2. The frontend sends the information to the local Python server.
3. Python validates the input and calculates pricing anchors independently.
4. The server sends the project brief to the local Ollama endpoint, requesting structured JSON from Gemma.
5. The generated project pack is returned to the browser, where the creator can review it and export the content as Markdown.

I kept the pricing calculations separate from the model so the cost estimates are based on explicit inputs rather than whatever numbers an AI might generate.

I also included a sample preview for people who want to explore the product without setting up local inference first.

One implementation detail I'm still refining is reliable structured generation through the app: Gemma responds to direct terminal prompts, but the app's structured request has encountered a token-repetition error during testing. The sample preview provides an alternative while I work on that integration.

Why Does Open Innovation Matter?

For FramePilot, open innovation is not just a technology choice. It is part of the product's value.

Freelancers may be working with unpublished campaign concepts, client budgets, contact details, locations, or other sensitive project information. A local-first workflow gives them more control over where those details go.

Because FramePilot uses a local Ollama instance by default, it does not need a paid cloud AI API key. After downloading the model, inference can run on the creator's own machine without sending briefs to a third-party AI service, provided the configured Ollama endpoint remains local.

Using an open-weight model also gives the project room to evolve. The model can be changed, prompts can be adapted to a particular creative niche, and the workflow can be improved without redesigning the whole product around a closed API.

Of course, local inference has trade-offs: users need disk space for the model, compatible hardware, and patience if their machine generates responses slowly. But for a small tool aimed at independent creators, the extra control and freedom from per-request cloud AI fees are compelling advantages.

Open innovation made it possible to build this around the creator's own machine, rather than making a third-party AI service a requirement.

Prize Categories

• Best Use of Gemma — Gemma 3 4B is the open-weight model used for FramePilot's local AI workflow.

devchallenge #hf26challenge