I built a side project that turns YouTube videos into study notes — here's what I learned shipping solo

Source: Dev.to

Introduction

I’m a game developer who ships games at a studio for my day job. I assumed that experience would make building a solo web app easier—it didn’t, not even close. This is the story of building and launching Lynote, a tool that turns any YouTube video into structured study notes, and everything I wish I’d known before I started.

The Problem

I watch a lot of YouTube to learn—tutorials, conference talks, university lectures, technical deep‑dives. While watching feels productive, I often realized that almost none of the material stuck when I tried to apply it. The root cause was passive consumption: watching isn’t learning. Real learning requires doing something with the information—summarising it, questioning it, testing yourself on it.

The Idea

I wanted a tool that would take a YouTube link and return a proper study note: a summary, key takeaways, action items, and flashcards—something I could actually use to review and retain what I’d watched. I couldn’t find exactly what I needed, so I built it.

Tech Stack

I chose familiar tools that would let me ship fast:

• Next.js 16 App Router – file‑based routing, server components, clean architecture
• React 19 – server actions made form handling much simpler than I expected
• Supabase – auth and database sorted in an afternoon; SSR integration worked smoothly
• OpenAI Responses API – the core of the generation pipeline
• Vercel – zero‑config deployment, exactly what you want when you’re solo

Nothing exotic; the goal was to spend energy on the product, not the infrastructure.

Challenges

Structured Output Across Video Types

Getting consistent, structured output from an LLM across wildly different video types was harder than expected. A 10‑minute tutorial has a very different transcript density than a 2‑hour university lecture. Short videos sometimes produced overly padded notes, while long videos hit token limits or lost coherence toward the end.

Solution: I ended up with a two‑pass approach for longer content—a chunking pass to extract key segments, then a synthesis pass to generate the final note. It’s not perfect, but it’s consistent enough that the output quality feels predictable regardless of video length.

Underestimating “Done”

• MVP in ~3 weeks.
• Additional 3 months spent on UI tweaks, refactoring, and adding features nobody had asked for yet—essentially procrastination disguised as polish.

Pricing Over‑Thinking

I spent days on pricing models when I should have just shipped a free tier and figured it out from real usage data. Token packs are live now; subscription billing is still not implemented. Ship first, figure out money second.

Product Decisions

Engineering was the easy part. Deciding what to show, what to cut, and how to structure the output took longer than any code.

What Worked

• Building something I personally needed – I used the tool every day while building it, so bugs bothered me directly and the feedback loop was immediate.
• Keeping the stack boring – familiar tools meant I never got stuck on infrastructure.
• Shipping before feeling ready – the version I launched is not the version I wanted to launch, and that’s fine.

Launch

Lynote is live at Lynote.

• Free tier: 10 notes per day, no account required.
• Token packs for heavier users.

Takeaways for Solo Builders

It’s my first solo product launch. If you’re a developer thinking about building something on the side, my only advice is:

• Start smaller than you think you need.
• Ship faster than feels comfortable.

Happy to answer any questions about the stack, the prompt engineering, or the experience of building solo as a game dev.