From Video Producer to SaaS Founder: Building TAGiT with AI

How I built a Chrome extension with 15,000+ lines of TypeScript in three months without traditional coding background—and what they don't tell you about building with AI.

Six months ago, I was only a filmmaker with two decades of video production experience and zero lines of production code to my name. Today, I'm the founder of TAGiT, a Chrome extension with over 15,000 lines of TypeScript, live on the Chrome Web Store, helping people remember what they watch.

This isn't another "I built a SaaS in a weekend with AI" story. This is what actually happens when you build something real.

The Problem I Couldn't Ignore

As a documentary filmmaker and video producer, I spent countless hours consuming educational content on YouTube—tutorials, podcasts, interviews, technical deep-dives. But here's the frustrating part: I was forgetting 90% of what I watched within a week.

I tried everything. Screenshots? Primitive and scattered across my desktop. Note-taking apps? Too slow—by the time I'd typed a note, I'd missed three other insights. YouTube's native bookmarks? Useless for actually retaining information.

The real pain hit when I'd need to reference something I knew I'd learned from a video. I'd spend 20 minutes scrubbing through hour-long videos, trying to find that one moment. It was maddening.

The Insight

If I was struggling with this as someone who works with video professionally, how many millions of students, researchers, and professionals were facing the same problem?

Enter TAGiT: Click When It Clicks

I envisioned a simple solution: tag the exact moment something important happens in a video. One click (or keyboard shortcut), and that moment is saved with:

•An AI-powered summary of what was said
•Automatically generated flashcards for spaced repetition
•The full transcript of that segment
•Instant jump-back to that exact timestamp
•Full-text search across your entire video library

Simple concept. But building it? That's where reality hit.

What They Don't Tell You About Building with AI

Week 1: The Honeymoon Phase

I dove in with Claude AI (Anthropic's assistant). The first prototype came together fast—maybe 30% of what I needed. It felt magical. I could describe what I wanted, and code appeared. "This is easier than everyone says!" I thought.

Reality check: That 30% was the easy part.

Weeks 2-3: Welcome to Production

Then came the challenges AI can't just "solve":

•Chrome extension permissions - Security policies, content script limitations, service worker constraints
•Database architecture - Supabase setup, Row Level Security, authentication flows
•Real-world integration - YouTube's DOM changes constantly, transcript extraction isn't straightforward, state management gets complex fast
•User experience - Loading states, error handling, edge cases that only surface in production

AI helped me write the code faster, but I still needed to understand what I was building. APIs, databases, authentication, deployment—these aren't magic words you whisper to AI. You need to grasp the fundamentals.

Months 1-2: The Polish Phase

Testing. Optimization. Security hardening. Bug fixing. This is where 70% of development time actually goes.

AI accelerated my learning curve dramatically—I could ask "why is this authentication flow failing?" and get a detailed explanation with fixes. But I still had to:

•Debug production issues at 2 AM
•Write comprehensive tests (62 API route tests and counting)
•Handle edge cases I never imagined
•Optimize for performance and security
•Learn about Chrome Web Store policies
•Set up proper deployment pipelines

The Non-Developer Advantages

Here's what surprised me: not having a traditional CS background was actually an advantage in some ways.

•User empathy - I built the tool I desperately needed. Every feature solved a real pain point I'd experienced.
•Pattern recognition - Years of editing video taught me to see workflows and optimize them. Software is just another medium.
•Persistence - Documentary filmmaking teaches you that projects take time. I wasn't expecting overnight success.
•AI tool mastery - I'd spent years learning how to collaborate with AI effectively. That skill compounds.

Myths vs. Reality

❌ Myth: "AI can build anything in a day"

Reality: AI can prototype fast. But production-ready products need architecture, testing, security, and polish. Budget months, not days.

❌ Myth: "No coding knowledge needed"

Reality: You need to understand concepts like APIs, databases, authentication, and deployment. AI accelerates learning, but you're still learning.

❌ Myth: "It just works"

Reality: Expect weeks of debugging, edge cases you never imagined, and integration issues. AI helps you solve them faster, but they still exist.

The Tech Stack

For the technically curious, here's what TAGiT is built on:

•Frontend: TypeScript, React 18, Next.js 15, Tailwind CSS
•Backend: Next.js API routes, Supabase (PostgreSQL with Row Level Security)
•AI: OpenAI GPT models for summaries and flashcards
•Payments: Stripe subscriptions (freemium model)
•Deployment: Netlify (dashboard), Chrome Web Store (extension)
•Testing: Jest, Testing Library (80%+ coverage)

What Actually Made This Possible

AI democratizes development, but it doesn't replace these fundamentals:

•Deep user empathy - I built this for myself first. Every decision was informed by real frustration.
•Willingness to iterate - The first version wasn't the final version. User feedback drove constant improvements.
•Systems thinking - Understanding how pieces fit together (extension → API → database → AI) came from asking "why" constantly.
•Persistence - Some bugs took days to solve. Some features required complete rewrites. That's normal.

Where We Are Now

TAGiT is live as a beta product on the Chrome Web Store. Early users are tagging videos, building personal knowledge libraries, and—most importantly—actually remembering what they watch.

The roadmap ahead includes:

•Mobile support (iOS/Android sharing integration)
•Collaborative features (share collections with teams)
•Advanced analytics (track your learning patterns)
•Integrations with note-taking tools (Notion, Obsidian)

Advice for Aspiring Builders

If you're thinking about building your first product with AI:

•Start with a problem you personally face - You'll have natural insight into what works
•Invest in learning AI collaboration - It's a skill. Practice prompt engineering, learn to debug AI-generated code, understand when to trust it and when to verify
•Budget 2-3 months minimum - Not because you can't build faster, but because quality takes time
•Focus on solving one problem exceptionally - TAGiT does one thing: helps you remember video content. That focus is our strength
•Get feedback early and often - Your assumptions will be wrong. Let users guide your roadmap

The Bottom Line

Can you build a real SaaS product with AI as a non-developer? Absolutely.

Will it be easy? No.

Is it worth it? Every single late night debugging session.

Building TAGiT taught me that the barrier to entry for creating software has dropped dramatically, but the barrier to creating great software remains high. AI is your co-pilot, but you're still the one flying the plane.

And honestly? I wouldn't have it any other way.

P.S. We will talk about the business side on another post.