On August 8, 2025, the first commit landed. Six months and 671 commits later, Neural Summary processes audio files up to 5GB, generates 30 types of professional documents, supports five languages, and serves users who trust it with their most important conversations.
I built it mostly solo. There was external help with design, some testing, and marketing, but the architecture, engineering, and product decisions were mine. This is the full story. Not a highlight reel. The real timeline, including what broke and what I'd do differently.
Month 1: The prototype (August 2025)
The first version was simple. Upload an audio file. Get a transcript. Get a summary.
The first real engineering problem arrived the same week: audio files are large, and speech-to-text APIs have size limits. I built a splitting pipeline that chunks large files into segments, processes them in parallel, and merges the results in chronological order. That pipeline, hardened over time, still runs in production today.
In the same week, I added multi-language support: English, Dutch, German, French, Spanish. Not just UI translations, but language-aware AI generation. Every document the system produces respects the user's language.
It felt like overkill for a prototype. It wasn't. Users work internationally. Their conversations cross language boundaries. Supporting that from the start meant I never had to retrofit it. Retrofitting i18n into AI-generated content is significantly harder than retrofitting it into a UI.
By mid-August: a working deployment with Docker, a monorepo (NestJS backend, Next.js frontend, shared TypeScript types), and the first version of what would become the lens system. The monorepo was a deliberate choice: shared types between frontend and backend prevent an entire class of integration bugs. The queue-based processing architecture was another early bet that paid off: audio transcription is slow, so everything was asynchronous from day one with a job queue and WebSocket progress updates.
Month 2: The first users (September 2025)
September was about making the product shareable. Link-based transcript sharing, email distribution, analytics, a landing page.
Real people started using it. That changed everything.
The gap between what I'd built and what users needed was immediately obvious. The product worked, but the output was generic. A sales call and a coaching session produced identical summaries. That's not useful. A sales professional needs a follow-up email and CRM notes. A coach needs session notes with developmental observations. Same input, fundamentally different outputs. The one-size-fits-all approach had to go.
I also shipped a sharing feature in this phase that, in hindsight, was premature. The mechanics worked, but the experience wasn't thought through: how sharing fits into a user's workflow, what the recipient sees, how it drives them back to the product. Sharing is a gateway to virality, and shipping it half-baked meant missing that opportunity. It's still on the list to rethink properly.
Month 3: The V2 rewrite (October 2025)
October was the biggest single month in the project's history.
The old system generated markdown. The new system generates structured JSON. This sounds like a technical detail, but it changed everything. Structured output meant I could validate quality against schemas, render the same content in five languages without re-processing, search across specific fields instead of full text, and build new features on top of existing data. Markdown would have been a dead end.
I launched 15 analysis templates in a single release. Each one was a different lens, a specific analytical perspective applied to a conversation. A sales call could produce a follow-up email, CRM notes, and action items. A strategy session could produce a brief, a decision log, and a process diagram. Same conversation, multiple outputs.
In the same release: subscription billing, usage tracking, a free tier. And then a pre-launch security audit turned up eight vulnerabilities in my own code: command injection in the media pipeline (CVSS 9.8), missing rate limiting, weak hashing, database injection risks, cross-site scripting vectors. All eight fixed before launch. There was no discussion about shipping with known vulnerabilities when users trust you with their conversations.
V2.0.0 shipped on October 31.
Month 4: The rebrand (November-December 2025)
This period was three releases in quick succession, and looking back, I should have combined them into one. But the rebrand was a turning point for the product and I was eager to ship it.
The surface change: primary color from pink to purple, typeface to Montserrat, 92 component files updated. The deeper change: the product went from feeling like a prototype to feeling like a product. Folder organization, recording recovery, profile photos, dark mode with an inline theme script that prevents the white flash on page load, skeleton loading states, micro-animations. None of these are headline features. All of them are the features that tell a user: someone cares about the details of your daily experience.
The performance work mattered too. Memoized React contexts to prevent cascading re-renders. Pre-computed folder counts to eliminate O(n x m) rendering. Parallelized database writes that cut folder deletion from 30 seconds to under 1 second for 50+ items. The kind of work nobody notices unless you don't do it.
Three releases in one month was too many. Each one introduced subtle regressions. A two-week stabilization cycle between majors would have been worth the slower pace.
Month 5: The lens redesign (January-February 2026)
This is the phase I'm most proud of.
I took every template and redesigned it from scratch. The standard was simple: if a senior consultant or product manager wouldn't be comfortable sending the output to a client, the template wasn't good enough. That bar came from my own background at a top-tier consulting firm, where the quality of a deliverable is non-negotiable regardless of how quickly it was produced.
I spent hours reading consulting deliverables, sales playbooks, and product specs. Not to copy formats, but to understand what makes a professional document feel professional. Structure. Clarity. Leading with the recommendation, not the context. Every finding answering "so what?"
Executive summaries became Pyramid Principle briefs with governing recommendations. CRM notes became sales intelligence with BANT qualification and stakeholder mapping. Coaching notes became developmental intelligence with classified key moments. The prompts, several hundred words each and the most carefully written text in the codebase, position the AI as a specific domain expert with examples of both good and bad output.
Fifteen templates became thirty, organized into five categories from passive to active: Capture, Analyze, Communicate, Deliver, Act. The key insight from this phase: prompts matter more than models. A well-designed prompt with clear structure and domain-expert positioning consistently outperforms a vague prompt on a more powerful model.
Month 6: Streaming chat and cross-conversation intelligence (March-April 2026)
Two features defined this month.
Streaming AI chat lets users have a conversation about their conversation. Ask questions, get citations with timestamps and speaker names, explore the content interactively. The responses stream token by token using Server-Sent Events, with citation buffering that holds back incomplete references until they resolve. It feels like talking to someone who was in the room.
Folder-level intelligence lets users organize conversations into folders, then ask questions that span all of them. "What decisions have we made about pricing across the last 12 sales calls?" The system returns answers with citations referencing the specific conversation, timestamp, and speaker.
Together, these transformed the product from a document generator into a knowledge base. Conversations are no longer isolated recordings. They're a searchable, queryable body of institutional knowledge.
What I got right
The monorepo. Shared TypeScript types between frontend and backend mean that when a type changes, everything that depends on it breaks at compile time, not in production.
Queue-based processing from day one. I never had to retrofit asynchronous architecture. It scaled from one user to concurrent jobs without a rewrite.
Structured JSON over markdown. This single decision enabled multi-language support, semantic search, quality validation, and the entire lens system.
Investing in the lenses. The product differentiation isn't in the transcription. Every competitor transcribes. The differentiation is in what the system produces afterward. The lenses are the product.
What I'd change
Earlier user research. The first three months were built primarily from my own intuition. Talking to users earlier would have accelerated the lens redesign and helped me find product-market fit faster.
The brand pivot earlier. I changed the brand twice: once from pink to purple, once from "voice-to-output creation platform" to "AI meeting notes for business professionals." Both pivots were right. But doing them months in meant updating hundreds of components and translations twice. Two weeks of brand clarity before writing code would have saved many more weeks later.
The sharing feature. I shipped it before the experience was ready. Sharing is one of the most important growth levers a product like this has. It's the moment a user puts your product in front of someone who's never heard of it. Getting that moment wrong means wasting the opportunity. It needs to be rethought from scratch.
Fewer releases, more stabilization. Three releases in one month taught me that shipping fast and shipping well aren't always the same thing.
What I've learned about building with AI
AI changed the development process fundamentally. Large portions of the codebase were written with AI assistance: architecture decisions, implementation, debugging, testing. The speed advantage is real and substantial. Six months of solo development produced a product that would have taken a team of three or four engineers a year to build without it.
But the thing AI doesn't replace is product thinking. The decision to use structured JSON over markdown. The insistence on consulting-grade output quality. The brand pivot from a generic positioning to a specific one. The choice to invest weeks in prompt engineering rather than shipping mediocre templates faster. None of those came from AI. They came from taste, experience, and an opinionated view of what the product should feel like.
If you're building something right now, the tools have never been better. A solo founder can ship a full-stack product with AI processing, real-time updates, multi-language support, and subscription billing in months. But the tools only amplify the decisions you make. Good product thinking and deliberate design are what separate a product that works from a product that matters. That hasn't changed.
