FlowGPT

FlowGPT — now part of Kaon — is an open-source AI app creator and prompt-sharing platform. TechCrunch described it as a "sort of app store for generative AI models like Google's Gemini, Anthropic's Claude, Meta's Llama 2 and OpenAI's DALL-E 3, as well as front-end experiences for those models." It was co-founded by Jay Dang (CEO, UC Berkeley CS dropout) and Lifan Wang (former engineering manager at Amazon) in 2023, headquartered in Berkeley.

I joined in June 2023, in the founding phase, while the team was still small enough to fit in one room. The product hadn't yet hit its inflection point. ChatGPT and prompt engineering were just becoming a mainstream conversation, and FlowGPT was about to ride that wave harder than almost anyone else.

In my first three months on the team, FlowGPT scaled from approximately one million to six million users. That growth wasn't linear — it was the curve you get when a product hits a cultural moment correctly. ChatGPT was the rocket; FlowGPT became the marketplace people used alongside it once they realized "good prompts" was a real category.

During the peak overlap, internal tracking showed FlowGPT capturing roughly 27% of ChatGPT visitor traffic — i.e., a meaningful fraction of people leaving or supplementing ChatGPT were ending up on us. That's the single most important number from this period: it's not "we got users," it's "we became part of the loop people were already running."

Engineering at FlowGPT during that growth phase wasn't one feature, ship, repeat. It was: pick the highest-leverage thing this week, design it end-to-end, ship it, instrument it, and move on. Day-to-day that meant working across:

• Marketplace surfaces — prompt detail, search, discovery — that had to render fast under SEO load and hold up while the user table was 6× larger than the month before
• Authenticated chat surfaces — streaming, optimistic updates, retry behaviour, the kind of latency-sensitive flow where every shortcut becomes an incident later
• Backend plumbing on a T3 stack — Next.js + tRPC + Prisma against Postgres, with Redis for caching and BullMQ for background jobs (recommendations, indexing, embeddings, the heavy operations you don't want in the request path)
• Reviewing PRs and pushing for changes that hold up under load — at our growth rate, "works on my machine" had a half-life of about 48 hours

• Next.js + tRPC + Prisma — the T3 stack core. End-to-end type safety reduces production incidents more than almost any other engineering investment at startup scale.
• Postgres as source of truth, Redis for hot-path caching and rate limits, BullMQ for background work that doesn't belong in the request cycle.
• TypeScript everywhere, strict mode, no any-bailouts in code review.
• Tailwind for UI, with a discipline-based component layer rather than a third-party design system — the team chose ergonomics over ceremony.

The lesson I carry forward: stack choice matters a fraction as much as the discipline you apply to it. The T3 stack at FlowGPT shipped well because we treated session validation, idempotency, and error boundaries as features, not fixtures.

These are company-level achievements, not individual ones. I list them because being part of a team that hits this level is itself a credential — it's the environment that shaped the work I shipped:

• $10M pre-Series A round led by Goodwater Capital, with existing backer DCM Ventures — reported by TechCrunch in February 2024
• Featured in The New York Times — the company and the prompt-marketplace category
• Featured on a Times Square billboard — Manhattan-tier brand placement during the peak prompt-engineering moment
• Hugging Face collaboration — partnership work bridging FlowGPT's prompt marketplace with the open-model ecosystem
• Sponsored by Google — sponsorship and credit support during a strategic phase
• Team grew from a small founding group to 150+ during my tenure — the company expanded from a single product into a multi-product organization that became Kaon

I include this section because the alternative — leaving these out — undersells the environment I worked in. Being on a team that hits press, billboard, and platform-partnership milestones inside an 18-month window teaches you things working on a stable team for five years doesn't.

• Growth phases don't reward cleverness; they punish slop. When the user table is doubling every six weeks, every shortcut you took yesterday becomes a 2am page tomorrow. I write more defensively than most engineers because of FlowGPT.
• The right architecture decision is the one you can defend in code review three months later. Moving prompt detail from CSR to RSC + ISR, choosing Postgres full-text over a managed search service, picking BullMQ over a roll-your-own queue — none of these were the smartest choice in isolation. They were the choices the team could maintain.
• A small founding team is a different organism than a 150-person company, and you have to learn both. I joined a startup; I left a structured engineering org. The transition is one of the most useful things I've learned that doesn't appear on any tech-stack list.